@pie-lib/editable-html-tip-tap 1.1.1-next.3 → 1.1.1-next.4

package/lib/components/__tests__/AltDialog.test.js

@@ -0,0 +1,201 @@
+"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 _AltDialog = require("../image/AltDialog");
+jest.mock('@mui/material/Dialog', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref) {
+      var children = _ref.children,
+        open = _ref.open,
+        id = _ref.id;
+      return open && /*#__PURE__*/_react["default"].createElement("div", {
+        id: id
+      }, children);
+    }
+  };
+});
+jest.mock('@mui/material/DialogContent', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_react["default"].createElement("div", null, children);
+    }
+  };
+});
+jest.mock('@mui/material/DialogActions', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref3) {
+      var children = _ref3.children;
+      return /*#__PURE__*/_react["default"].createElement("div", null, children);
+    }
+  };
+});
+jest.mock('@mui/material/Button', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref4) {
+      var children = _ref4.children,
+        onClick = _ref4.onClick;
+      return /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: onClick
+      }, children);
+    }
+  };
+});
+jest.mock('@mui/material/TextField', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref5) {
+      var value = _ref5.value,
+        onChange = _ref5.onChange,
+        placeholder = _ref5.placeholder,
+        helperText = _ref5.helperText,
+        FormHelperTextProps = _ref5.FormHelperTextProps,
+        multiline = _ref5.multiline;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: "MuiTextField-root"
+      }, /*#__PURE__*/_react["default"].createElement("textarea", {
+        value: value || '',
+        onChange: onChange,
+        placeholder: placeholder,
+        "data-multiline": multiline
+      }), helperText && /*#__PURE__*/_react["default"].createElement("div", {
+        style: FormHelperTextProps === null || FormHelperTextProps === void 0 ? void 0 : FormHelperTextProps.style
+      }, helperText));
+    }
+  };
+});
+jest.mock('@mui/icons-material/ArrowBackIos', function () {
+  return {
+    __esModule: true,
+    "default": function _default() {
+      return /*#__PURE__*/_react["default"].createElement("svg", {
+        "data-testid": "arrow-back-icon"
+      });
+    }
+  };
+});
+describe('AltDialog', function () {
+  var defaultProps = {
+    onDone: jest.fn(),
+    alt: 'Initial alt text'
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+    document.body.innerHTML = '';
+  });
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders with initial alt text', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render2.container;
+    var textarea = container.querySelector('textarea');
+    expect(textarea.value).toBe('Initial alt text');
+  });
+  it('renders placeholder text', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, (0, _extends2["default"])({}, defaultProps, {
+        alt: ""
+      }))),
+      getByPlaceholderText = _render3.getByPlaceholderText;
+    expect(getByPlaceholderText('Enter an Alt Text description of this image')).toBeInTheDocument();
+  });
+  it('renders helper text', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      getByText = _render4.getByText;
+    expect(getByText('Users with visual limitations rely on Alt Text, since screen readers cannot otherwise describe the contents of an image.')).toBeInTheDocument();
+  });
+  it('renders Done button', function () {
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      getByText = _render5.getByText;
+    expect(getByText('Done')).toBeInTheDocument();
+  });
+  it('renders ArrowBackIos icon', function () {
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      getByTestId = _render6.getByTestId;
+    expect(getByTestId('arrow-back-icon')).toBeInTheDocument();
+  });
+  it('updates value on text field change', function () {
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render7.container;
+    var textarea = container.querySelector('textarea');
+    _react2.fireEvent.change(textarea, {
+      target: {
+        value: 'New alt text'
+      }
+    });
+    expect(textarea.value).toBe('New alt text');
+  });
+  it('calls onDone with value when Done button is clicked', function () {
+    var onDone = jest.fn();
+    // Mock document.querySelectorAll to avoid DOM manipulation issues
+    var mockQuerySelectorAll = jest.spyOn(document, 'querySelectorAll').mockReturnValue([]);
+    var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, (0, _extends2["default"])({}, defaultProps, {
+        onDone: onDone
+      }))),
+      getByText = _render8.getByText,
+      container = _render8.container;
+    var textarea = container.querySelector('textarea');
+    _react2.fireEvent.change(textarea, {
+      target: {
+        value: 'Updated alt text'
+      }
+    });
+    _react2.fireEvent.click(getByText('Done'));
+    expect(onDone).toHaveBeenCalledWith('Updated alt text');
+    mockQuerySelectorAll.mockRestore();
+  });
+  it('closes dialog when Done button is clicked', function () {
+    // Mock document.querySelectorAll to avoid DOM manipulation issues
+    var mockQuerySelectorAll = jest.spyOn(document, 'querySelectorAll').mockReturnValue([]);
+    var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      getByText = _render9.getByText,
+      container = _render9.container;
+    var dialog = container.querySelector('#text-dialog');
+    expect(dialog).toBeInTheDocument();
+    _react2.fireEvent.click(getByText('Done'));
+    mockQuerySelectorAll.mockRestore();
+  });
+  it('dialog is open', function () {
+    var _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render0.container;
+    var dialog = container.querySelector('[id="text-dialog"]');
+    expect(dialog).toBeInTheDocument();
+  });
+  it('has correct dialog props', function () {
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render1.container;
+    var dialog = container.querySelector('[id="text-dialog"]');
+    expect(dialog).toBeInTheDocument();
+  });
+  it('text field is multiline', function () {
+    var _render10 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, defaultProps)),
+      container = _render10.container;
+    var textarea = container.querySelector('textarea');
+    expect(textarea.getAttribute('data-multiline')).toBe('true');
+  });
+  it('renders without alt text', function () {
+    var _render11 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, (0, _extends2["default"])({}, defaultProps, {
+        alt: undefined
+      }))),
+      getByPlaceholderText = _render11.getByPlaceholderText;
+    expect(getByPlaceholderText('Enter an Alt Text description of this image')).toBeInTheDocument();
+  });
+  it('handles empty alt text', function () {
+    var _render12 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_AltDialog.AltDialog, (0, _extends2["default"])({}, defaultProps, {
+        alt: ""
+      }))),
+      container = _render12.container;
+    var textarea = container.querySelector('textarea');
+    expect(textarea.value).toBe('');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_AltDialog","jest","mock","__esModule","default","_ref","children","open","id","createElement","_ref2","_ref3","_ref4","onClick","_ref5","value","onChange","placeholder","helperText","FormHelperTextProps","multiline","className","style","describe","defaultProps","onDone","fn","alt","beforeEach","clearAllMocks","document","body","innerHTML","it","_render","render","AltDialog","container","expect","toBeInTheDocument","_render2","textarea","querySelector","toBe","_render3","_extends2","getByPlaceholderText","_render4","getByText","_render5","_render6","getByTestId","_render7","fireEvent","change","target","mockQuerySelectorAll","spyOn","mockReturnValue","_render8","click","toHaveBeenCalledWith","mockRestore","_render9","dialog","_render0","_render1","_render10","getAttribute","_render11","undefined","_render12"],"sources":["../../../src/components/__tests__/AltDialog.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render } from '@testing-library/react';\nimport { AltDialog } from '../image/AltDialog';\n\njest.mock('@mui/material/Dialog', () => ({\n  __esModule: true,\n  default: ({ children, open, id }) => open && <div id={id}>{children}</div>,\n}));\n\njest.mock('@mui/material/DialogContent', () => ({\n  __esModule: true,\n  default: ({ children }) => <div>{children}</div>,\n}));\n\njest.mock('@mui/material/DialogActions', () => ({\n  __esModule: true,\n  default: ({ children }) => <div>{children}</div>,\n}));\n\njest.mock('@mui/material/Button', () => ({\n  __esModule: true,\n  default: ({ children, onClick }) => <button onClick={onClick}>{children}</button>,\n}));\n\njest.mock('@mui/material/TextField', () => ({\n  __esModule: true,\n  default: ({ value, onChange, placeholder, helperText, FormHelperTextProps, multiline }) => (\n    <div className=\"MuiTextField-root\">\n      <textarea value={value || ''} onChange={onChange} placeholder={placeholder} data-multiline={multiline} />\n      {helperText && <div style={FormHelperTextProps?.style}>{helperText}</div>}\n    </div>\n  ),\n}));\n\njest.mock('@mui/icons-material/ArrowBackIos', () => ({\n  __esModule: true,\n  default: () => <svg data-testid=\"arrow-back-icon\" />,\n}));\n\ndescribe('AltDialog', () => {\n  const defaultProps = {\n    onDone: jest.fn(),\n    alt: 'Initial alt text',\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    document.body.innerHTML = '';\n  });\n\n  it('renders without crashing', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('renders with initial alt text', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    const textarea = container.querySelector('textarea');\n    expect(textarea.value).toBe('Initial alt text');\n  });\n\n  it('renders placeholder text', () => {\n    const { getByPlaceholderText } = render(<AltDialog {...defaultProps} alt=\"\" />);\n    expect(getByPlaceholderText('Enter an Alt Text description of this image')).toBeInTheDocument();\n  });\n\n  it('renders helper text', () => {\n    const { getByText } = render(<AltDialog {...defaultProps} />);\n    expect(\n      getByText(\n        'Users with visual limitations rely on Alt Text, since screen readers cannot otherwise describe the contents of an image.',\n      ),\n    ).toBeInTheDocument();\n  });\n\n  it('renders Done button', () => {\n    const { getByText } = render(<AltDialog {...defaultProps} />);\n    expect(getByText('Done')).toBeInTheDocument();\n  });\n\n  it('renders ArrowBackIos icon', () => {\n    const { getByTestId } = render(<AltDialog {...defaultProps} />);\n    expect(getByTestId('arrow-back-icon')).toBeInTheDocument();\n  });\n\n  it('updates value on text field change', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    const textarea = container.querySelector('textarea');\n    fireEvent.change(textarea, { target: { value: 'New alt text' } });\n    expect(textarea.value).toBe('New alt text');\n  });\n\n  it('calls onDone with value when Done button is clicked', () => {\n    const onDone = jest.fn();\n    // Mock document.querySelectorAll to avoid DOM manipulation issues\n    const mockQuerySelectorAll = jest.spyOn(document, 'querySelectorAll').mockReturnValue([]);\n\n    const { getByText, container } = render(<AltDialog {...defaultProps} onDone={onDone} />);\n    const textarea = container.querySelector('textarea');\n    fireEvent.change(textarea, { target: { value: 'Updated alt text' } });\n    fireEvent.click(getByText('Done'));\n    expect(onDone).toHaveBeenCalledWith('Updated alt text');\n\n    mockQuerySelectorAll.mockRestore();\n  });\n\n  it('closes dialog when Done button is clicked', () => {\n    // Mock document.querySelectorAll to avoid DOM manipulation issues\n    const mockQuerySelectorAll = jest.spyOn(document, 'querySelectorAll').mockReturnValue([]);\n\n    const { getByText, container } = render(<AltDialog {...defaultProps} />);\n    const dialog = container.querySelector('#text-dialog');\n    expect(dialog).toBeInTheDocument();\n    fireEvent.click(getByText('Done'));\n\n    mockQuerySelectorAll.mockRestore();\n  });\n\n  it('dialog is open', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    const dialog = container.querySelector('[id=\"text-dialog\"]');\n    expect(dialog).toBeInTheDocument();\n  });\n\n  it('has correct dialog props', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    const dialog = container.querySelector('[id=\"text-dialog\"]');\n    expect(dialog).toBeInTheDocument();\n  });\n\n  it('text field is multiline', () => {\n    const { container } = render(<AltDialog {...defaultProps} />);\n    const textarea = container.querySelector('textarea');\n    expect(textarea.getAttribute('data-multiline')).toBe('true');\n  });\n\n  it('renders without alt text', () => {\n    const { getByPlaceholderText } = render(<AltDialog {...defaultProps} alt={undefined} />);\n    expect(getByPlaceholderText('Enter an Alt Text description of this image')).toBeInTheDocument();\n  });\n\n  it('handles empty alt text', () => {\n    const { container } = render(<AltDialog {...defaultProps} alt=\"\" />);\n    const textarea = container.querySelector('textarea');\n    expect(textarea.value).toBe('');\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/components/__tests__/CharacterPicker.test.js

@@ -0,0 +1,305 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _CharacterPicker = require("../CharacterPicker");
+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('react-dom', function () {
+  return _objectSpread(_objectSpread({}, jest.requireActual('react-dom')), {}, {
+    createPortal: function createPortal(node) {
+      return node;
+    }
+  });
+});
+jest.mock('@pie-lib/math-toolbar', function () {
+  return {
+    PureToolbar: function PureToolbar(_ref) {
+      var onChange = _ref.onChange,
+        onDone = _ref.onDone,
+        additionalKeys = _ref.additionalKeys;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "pure-toolbar"
+      }, /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: function onClick() {
+          return onChange('á');
+        },
+        "data-testid": "char-button"
+      }, "\xE1"), /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: onDone,
+        "data-testid": "done-button"
+      }, "Done"));
+    }
+  };
+});
+jest.mock('../characters/custom-popper', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref2) {
+      var children = _ref2.children,
+        onClose = _ref2.onClose;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "custom-popper"
+      }, children, /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: onClose,
+        "data-testid": "close-popper"
+      }, "Close"));
+    }
+  };
+});
+describe('CharacterIcon', function () {
+  it('renders with letter', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterIcon, {
+        letter: "\xF1"
+      })),
+      getByText = _render.getByText;
+    expect(getByText('ñ')).toBeInTheDocument();
+  });
+  it('renders with correct styling', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterIcon, {
+        letter: "\u20AC"
+      })),
+      container = _render2.container;
+    var div = container.firstChild;
+    expect(div).toHaveStyle({
+      fontSize: '24px',
+      lineHeight: '24px'
+    });
+  });
+});
+describe('CharacterPicker', function () {
+  var mockEditor = {
+    chain: jest.fn(function () {
+      return {
+        focus: jest.fn(function () {
+          return {
+            insertContent: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            })
+          };
+        })
+      };
+    }),
+    options: {
+      element: document.createElement('div')
+    },
+    view: {
+      coordsAtPos: jest.fn(function () {
+        return {
+          top: 100,
+          left: 50
+        };
+      }),
+      dom: document.createElement('div')
+    },
+    state: {
+      selection: {
+        from: 0
+      }
+    }
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+    // Reset the element to avoid "Cannot redefine property" error
+    mockEditor.options.element = document.createElement('div');
+    Object.defineProperty(mockEditor.options.element, 'getBoundingClientRect', {
+      value: jest.fn(function () {
+        return {
+          top: 0,
+          left: 0,
+          height: 100
+        };
+      }),
+      configurable: true
+    });
+  });
+  it('returns null when opts has no characters', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: {},
+        onClose: jest.fn()
+      })),
+      container = _render3.container;
+    expect(container.firstChild).toBeNull();
+  });
+  it('returns null when opts is not provided', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: null,
+        onClose: jest.fn()
+      })),
+      container = _render4.container;
+    expect(container.firstChild).toBeNull();
+  });
+  it('renders character picker with spanish config', function () {
+    var opts = {
+      language: 'spanish',
+      characters: [['á', 'é', 'í']]
+    };
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      getByTestId = _render5.getByTestId;
+    expect(getByTestId('pure-toolbar')).toBeInTheDocument();
+  });
+  it('renders character picker with special config', function () {
+    var opts = {
+      language: 'special',
+      characters: [['€', '£']]
+    };
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      getByTestId = _render6.getByTestId;
+    expect(getByTestId('pure-toolbar')).toBeInTheDocument();
+  });
+  it('handles character insertion', function () {
+    var opts = {
+      characters: [['á', 'é']]
+    };
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      getByTestId = _render7.getByTestId;
+    _react2.fireEvent.click(getByTestId('char-button'));
+    expect(mockEditor.chain).toHaveBeenCalled();
+  });
+  it('calls onClose when done button is clicked', function () {
+    var onClose = jest.fn();
+    var opts = {
+      characters: [['á', 'é']]
+    };
+    var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: onClose
+      })),
+      getByTestId = _render8.getByTestId;
+    _react2.fireEvent.click(getByTestId('done-button'));
+    expect(onClose).toHaveBeenCalled();
+  });
+  it('closes on outside click', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var onClose, opts;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          onClose = jest.fn();
+          opts = {
+            characters: [['á', 'é']]
+          };
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+            editor: mockEditor,
+            opts: opts,
+            onClose: onClose
+          }));
+          _context.next = 1;
+          return (0, _react2.waitFor)(function () {
+            setTimeout(function () {
+              _react2.fireEvent.click(document.body);
+            }, 0);
+          });
+        case 1:
+          expect(onClose).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('does not close when clicking inside picker', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var onClose, opts, _render9, container;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onClose = jest.fn();
+          opts = {
+            characters: [['á', 'é']]
+          };
+          _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+            editor: mockEditor,
+            opts: opts,
+            onClose: onClose
+          })), container = _render9.container;
+          _context2.next = 1;
+          return (0, _react2.waitFor)(function () {
+            var picker = container.querySelector('.insert-character-dialog');
+            if (picker) {
+              _react2.fireEvent.mouseDown(picker);
+            }
+          });
+        case 1:
+          expect(onClose).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('renders with custom opts structure', function () {
+    var opts = {
+      characters: [[{
+        name: 'a',
+        write: 'á',
+        label: 'á'
+      }, {
+        name: 'e',
+        write: 'é',
+        label: 'é'
+      }]]
+    };
+    var _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      getByTestId = _render0.getByTestId;
+    expect(getByTestId('pure-toolbar')).toBeInTheDocument();
+  });
+  it('renders with hasPreview option', function () {
+    var opts = {
+      hasPreview: true,
+      characters: [[{
+        name: 'euro',
+        write: '€',
+        label: '€',
+        description: 'Euro sign',
+        unicode: 'U+20AC'
+      }]]
+    };
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      getByTestId = _render1.getByTestId;
+    expect(getByTestId('pure-toolbar')).toBeInTheDocument();
+  });
+  it('calculates position correctly', function () {
+    var opts = {
+      characters: [['á']]
+    };
+    var _render10 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CharacterPicker.CharacterPicker, {
+        editor: mockEditor,
+        opts: opts,
+        onClose: jest.fn()
+      })),
+      container = _render10.container;
+    var dialog = container.querySelector('.insert-character-dialog');
+    expect(dialog).toHaveStyle({
+      position: 'absolute'
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_CharacterPicker","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","requireActual","createPortal","node","PureToolbar","_ref","onChange","onDone","additionalKeys","createElement","onClick","__esModule","default","_ref2","children","onClose","describe","it","_render","render","CharacterIcon","letter","getByText","expect","toBeInTheDocument","_render2","container","div","firstChild","toHaveStyle","fontSize","lineHeight","mockEditor","chain","fn","focus","insertContent","run","options","element","document","view","coordsAtPos","top","left","dom","state","selection","from","beforeEach","clearAllMocks","value","height","configurable","_render3","CharacterPicker","editor","opts","toBeNull","_render4","language","characters","_render5","getByTestId","_render6","_render7","fireEvent","click","toHaveBeenCalled","_render8","_asyncToGenerator2","_regenerator","mark","_callee","wrap","_context","prev","next","waitFor","setTimeout","body","stop","_callee2","_render9","_context2","picker","querySelector","mouseDown","not","name","write","label","_render0","hasPreview","description","unicode","_render1","_render10","dialog","position"],"sources":["../../../src/components/__tests__/CharacterPicker.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render, waitFor } from '@testing-library/react';\nimport { CharacterIcon, CharacterPicker } from '../CharacterPicker';\n\njest.mock('react-dom', () => ({\n  ...jest.requireActual('react-dom'),\n  createPortal: (node) => node,\n}));\n\njest.mock('@pie-lib/math-toolbar', () => ({\n  PureToolbar: ({ onChange, onDone, additionalKeys }) => (\n    <div data-testid=\"pure-toolbar\">\n      <button onClick={() => onChange('á')} data-testid=\"char-button\">\n        á\n      </button>\n      <button onClick={onDone} data-testid=\"done-button\">\n        Done\n      </button>\n    </div>\n  ),\n}));\n\njest.mock('../characters/custom-popper', () => ({\n  __esModule: true,\n  default: ({ children, onClose }) => (\n    <div data-testid=\"custom-popper\">\n      {children}\n      <button onClick={onClose} data-testid=\"close-popper\">\n        Close\n      </button>\n    </div>\n  ),\n}));\n\ndescribe('CharacterIcon', () => {\n  it('renders with letter', () => {\n    const { getByText } = render(<CharacterIcon letter=\"ñ\" />);\n    expect(getByText('ñ')).toBeInTheDocument();\n  });\n\n  it('renders with correct styling', () => {\n    const { container } = render(<CharacterIcon letter=\"€\" />);\n    const div = container.firstChild;\n    expect(div).toHaveStyle({ fontSize: '24px', lineHeight: '24px' });\n  });\n});\n\ndescribe('CharacterPicker', () => {\n  const mockEditor = {\n    chain: jest.fn(() => ({\n      focus: jest.fn(() => ({\n        insertContent: jest.fn(() => ({ run: jest.fn() })),\n      })),\n    })),\n    options: {\n      element: document.createElement('div'),\n    },\n    view: {\n      coordsAtPos: jest.fn(() => ({ top: 100, left: 50 })),\n      dom: document.createElement('div'),\n    },\n    state: {\n      selection: { from: 0 },\n    },\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    // Reset the element to avoid \"Cannot redefine property\" error\n    mockEditor.options.element = document.createElement('div');\n    Object.defineProperty(mockEditor.options.element, 'getBoundingClientRect', {\n      value: jest.fn(() => ({ top: 0, left: 0, height: 100 })),\n      configurable: true,\n    });\n  });\n\n  it('returns null when opts has no characters', () => {\n    const { container } = render(<CharacterPicker editor={mockEditor} opts={{}} onClose={jest.fn()} />);\n    expect(container.firstChild).toBeNull();\n  });\n\n  it('returns null when opts is not provided', () => {\n    const { container } = render(<CharacterPicker editor={mockEditor} opts={null} onClose={jest.fn()} />);\n    expect(container.firstChild).toBeNull();\n  });\n\n  it('renders character picker with spanish config', () => {\n    const opts = {\n      language: 'spanish',\n      characters: [['á', 'é', 'í']],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    expect(getByTestId('pure-toolbar')).toBeInTheDocument();\n  });\n\n  it('renders character picker with special config', () => {\n    const opts = {\n      language: 'special',\n      characters: [['€', '£']],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    expect(getByTestId('pure-toolbar')).toBeInTheDocument();\n  });\n\n  it('handles character insertion', () => {\n    const opts = {\n      characters: [['á', 'é']],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    fireEvent.click(getByTestId('char-button'));\n    expect(mockEditor.chain).toHaveBeenCalled();\n  });\n\n  it('calls onClose when done button is clicked', () => {\n    const onClose = jest.fn();\n    const opts = {\n      characters: [['á', 'é']],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={onClose} />);\n    fireEvent.click(getByTestId('done-button'));\n    expect(onClose).toHaveBeenCalled();\n  });\n\n  it('closes on outside click', async () => {\n    const onClose = jest.fn();\n    const opts = {\n      characters: [['á', 'é']],\n    };\n    render(<CharacterPicker editor={mockEditor} opts={opts} onClose={onClose} />);\n\n    await waitFor(() => {\n      setTimeout(() => {\n        fireEvent.click(document.body);\n      }, 0);\n    });\n\n    expect(onClose).toHaveBeenCalled();\n  });\n\n  it('does not close when clicking inside picker', async () => {\n    const onClose = jest.fn();\n    const opts = {\n      characters: [['á', 'é']],\n    };\n    const { container } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={onClose} />);\n\n    await waitFor(() => {\n      const picker = container.querySelector('.insert-character-dialog');\n      if (picker) {\n        fireEvent.mouseDown(picker);\n      }\n    });\n\n    expect(onClose).not.toHaveBeenCalled();\n  });\n\n  it('renders with custom opts structure', () => {\n    const opts = {\n      characters: [\n        [\n          { name: 'a', write: 'á', label: 'á' },\n          { name: 'e', write: 'é', label: 'é' },\n        ],\n      ],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    expect(getByTestId('pure-toolbar')).toBeInTheDocument();\n  });\n\n  it('renders with hasPreview option', () => {\n    const opts = {\n      hasPreview: true,\n      characters: [\n        [\n          {\n            name: 'euro',\n            write: '€',\n            label: '€',\n            description: 'Euro sign',\n            unicode: 'U+20AC',\n          },\n        ],\n      ],\n    };\n    const { getByTestId } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    expect(getByTestId('pure-toolbar')).toBeInTheDocument();\n  });\n\n  it('calculates position correctly', () => {\n    const opts = {\n      characters: [['á']],\n    };\n    const { container } = render(<CharacterPicker editor={mockEditor} opts={opts} onClose={jest.fn()} />);\n    const dialog = container.querySelector('.insert-character-dialog');\n    expect(dialog).toHaveStyle({ position: 'absolute' });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/components/__tests__/CssIcon.test.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _CssIcon = _interopRequireDefault(require("../icons/CssIcon"));
+describe('CssIcon', function () {
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders CSS text', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render2.getByText;
+    expect(getByText('CSS')).toBeInTheDocument();
+  });
+  it('applies correct font family', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render3.getByText;
+    var element = getByText('CSS');
+    // Font family is applied via styled component, just verify text renders
+    expect(element).toBeInTheDocument();
+  });
+  it('applies bold font weight', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render4.getByText;
+    var element = getByText('CSS');
+    expect(element).toHaveStyle({
+      fontWeight: 'bold'
+    });
+  });
+  it('has correct line height', function () {
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render5.getByText;
+    var element = getByText('CSS');
+    expect(element).toHaveStyle({
+      lineHeight: '14px'
+    });
+  });
+  it('has relative positioning', function () {
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render6.getByText;
+    var element = getByText('CSS');
+    expect(element).toHaveStyle({
+      position: 'relative'
+    });
+  });
+  it('has nowrap white space', function () {
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_CssIcon["default"], null)),
+      getByText = _render7.getByText;
+    var element = getByText('CSS');
+    expect(element).toHaveStyle({
+      whiteSpace: 'nowrap'
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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