@projectcor/maia-components 2.49.0-beta.1 → 2.49.1-0

package/lib/components/atoms/AttachmentPreviewModal/AttachmentPreviewModal.spec.js

@@ -0,0 +1,396 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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) { _defineProperty(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; }
+import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { ensurePortalRoot } from '../../../test/portalRoot';
+import { AttachmentPreviewModal } from './AttachmentPreviewModal';
+import { downloadFileFromUrl } from '../../../utils/fileDownloadHelper';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 11112;
+    }
+  };
+});
+jest.mock('@projectcor/cor-commons/lib/components/spinner-lottie/SpinnerLottie', function () {
+  return {
+    SpinnerLottie: function SpinnerLottie() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "spinner"
+      });
+    }
+  };
+});
+jest.mock('../ImagePreview/ImagePreview', function () {
+  return {
+    ImagePreview: function ImagePreview(_ref) {
+      var src = _ref.src,
+        alt = _ref.alt;
+      return /*#__PURE__*/_jsx("img", {
+        src: src,
+        alt: alt
+      });
+    }
+  };
+});
+jest.mock('./ExcelPreview', function () {
+  return {
+    ExcelPreview: function ExcelPreview() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "excel-preview"
+      });
+    }
+  };
+});
+jest.mock('./WordPreview', function () {
+  return {
+    WordPreview: function WordPreview() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "word-preview"
+      });
+    }
+  };
+});
+jest.mock('./PptPreview', function () {
+  return {
+    PptPreview: function PptPreview() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "ppt-preview"
+      });
+    }
+  };
+});
+jest.mock('../MaiaStreamdown', function () {
+  return {
+    MaiaStreamdown: function MaiaStreamdown(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_jsx("div", {
+        children: children
+      });
+    }
+  };
+});
+jest.mock('../../../utils/fileDownloadHelper', function () {
+  return {
+    downloadFileFromUrl: jest.fn()
+  };
+});
+var downloadFileFromUrlMock = downloadFileFromUrl;
+var buildAttachment = function buildAttachment() {
+  var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return _objectSpread({
+    id: 'file-1',
+    name: 'photo.png',
+    type: 'image/png',
+    size: 100,
+    file: new File([], 'photo.png', {
+      type: 'image/png'
+    })
+  }, overrides);
+};
+describe('AttachmentPreviewModal', function () {
+  var cleanupPortal;
+  beforeEach(function () {
+    cleanupPortal = ensurePortalRoot('modal-root-actions');
+    global.URL.createObjectURL = jest.fn(function () {
+      return 'blob:preview-test';
+    });
+    global.URL.revokeObjectURL = jest.fn();
+    downloadFileFromUrlMock.mockReset();
+  });
+  afterEach(function () {
+    cleanupPortal();
+  });
+  it('returns null when closed or without portal root', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+        isOpen: false,
+        onClose: jest.fn(),
+        attachment: buildAttachment()
+      })),
+      container = _renderWithProviders.container,
+      rerender = _renderWithProviders.rerender;
+    expect(container).toBeEmptyDOMElement();
+    cleanupPortal();
+    rerender(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+      isOpen: true,
+      onClose: jest.fn(),
+      attachment: buildAttachment()
+    }));
+    expect(container).toBeEmptyDOMElement();
+    cleanupPortal = ensurePortalRoot('modal-root-actions');
+  });
+  it('renders an image preview from url_original', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              url_original: 'https://cdn.test/photo.png'
+            })
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            expect(screen.getByAltText('photo.png')).toHaveAttribute('src', 'https://cdn.test/photo.png');
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('renders text content for local txt files', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'notes.txt',
+              type: 'text/plain',
+              file: new File(['hello preview'], 'notes.txt', {
+                type: 'text/plain'
+              })
+            })
+          }));
+          _context2.next = 1;
+          return waitFor(function () {
+            expect(screen.getByText('hello preview')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('shows unsupported message for unknown file types', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'archive.zip',
+              type: 'application/zip',
+              file: new File(['zip'], 'archive.zip', {
+                type: 'application/zip'
+              })
+            })
+          }));
+          _context3.next = 1;
+          return waitFor(function () {
+            expect(screen.getByText('chat.attachmentPreviewModal.unsupportedFileMessage')).toBeInTheDocument();
+            expect(screen.getByText('archive.zip')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('closes on escape and from the header button', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var onClose;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          onClose = jest.fn();
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: onClose,
+            attachment: buildAttachment({
+              url_original: 'https://cdn.test/photo.png'
+            })
+          }));
+          _context4.next = 1;
+          return waitFor(function () {
+            expect(screen.getByAltText('photo.png')).toBeInTheDocument();
+          });
+        case 1:
+          fireEvent.keyDown(document, {
+            key: 'Escape'
+          });
+          expect(onClose).toHaveBeenCalledTimes(1);
+          fireEvent.click(document.querySelector('button[data-icon-only="true"]'));
+          expect(onClose).toHaveBeenCalledTimes(2);
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('renders pdf preview from a local file blob', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'brief.pdf',
+              type: 'application/pdf',
+              file: new File(['pdf'], 'brief.pdf', {
+                type: 'application/pdf'
+              })
+            })
+          }));
+          _context5.next = 1;
+          return waitFor(function () {
+            expect(document.querySelector('iframe[title="brief.pdf"]')).toHaveAttribute('src', 'blob:preview-test');
+          });
+        case 1:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('renders markdown content for local md files', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'notes.md',
+              type: 'text/markdown',
+              file: new File(['# Title'], 'notes.md', {
+                type: 'text/markdown'
+              })
+            })
+          }));
+          _context6.next = 1;
+          return waitFor(function () {
+            expect(screen.getByText('# Title')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('uses thumbnail url when original image url is missing', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    return _regeneratorRuntime.wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              url_thumbnail: 'https://cdn.test/thumb.png'
+            })
+          }));
+          _context7.next = 1;
+          return waitFor(function () {
+            expect(screen.getByAltText('photo.png')).toHaveAttribute('src', 'https://cdn.test/thumb.png');
+          });
+        case 1:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it('downloads remote files and renders excel preview', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          downloadFileFromUrlMock.mockResolvedValue(new File(['excel'], 'sheet.xlsx', {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+          }));
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'sheet',
+              type: 'xlsx',
+              file: undefined,
+              url_original: 'https://cdn.test/sheet.xlsx'
+            })
+          }));
+          _context8.next = 1;
+          return waitFor(function () {
+            expect(downloadFileFromUrlMock).toHaveBeenCalled();
+            expect(screen.getByText('excel-preview')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('renders office previews from url_original', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    return _regeneratorRuntime.wrap(function (_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'brief.docx',
+              type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+              file: undefined,
+              url_original: 'https://cdn.test/brief.docx'
+            })
+          }));
+          _context9.next = 1;
+          return waitFor(function () {
+            expect(screen.getByText('word-preview')).toBeInTheDocument();
+          });
+        case 1:
+          cleanupPortal();
+          cleanupPortal = ensurePortalRoot('modal-root-actions');
+          renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: jest.fn(),
+            attachment: buildAttachment({
+              name: 'deck.pptx',
+              type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+              file: undefined,
+              url_original: 'https://cdn.test/deck.pptx'
+            })
+          }));
+          _context9.next = 2;
+          return waitFor(function () {
+            expect(screen.getByText('ppt-preview')).toBeInTheDocument();
+          });
+        case 2:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  it('closes when clicking the backdrop', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+    var _container$firstEleme;
+    var onClose, _renderWithProviders2, container, backdrop;
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          onClose = jest.fn();
+          _renderWithProviders2 = renderWithProviders(/*#__PURE__*/_jsx(AttachmentPreviewModal, {
+            isOpen: true,
+            onClose: onClose,
+            attachment: buildAttachment({
+              url_original: 'https://cdn.test/photo.png'
+            })
+          })), container = _renderWithProviders2.container;
+          _context0.next = 1;
+          return waitFor(function () {
+            expect(screen.getByAltText('photo.png')).toBeInTheDocument();
+          });
+        case 1:
+          backdrop = (_container$firstEleme = container.firstElementChild) === null || _container$firstEleme === void 0 ? void 0 : _container$firstEleme.firstElementChild;
+          fireEvent.click(backdrop);
+          expect(onClose).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","waitFor","ensurePortalRoot","AttachmentPreviewModal","downloadFileFromUrl","jsx","_jsx","jest","mock","useMaiaTaskPanelZIndex","SpinnerLottie","children","ImagePreview","_ref","src","alt","ExcelPreview","WordPreview","PptPreview","MaiaStreamdown","_ref2","fn","downloadFileFromUrlMock","buildAttachment","overrides","arguments","length","undefined","_objectSpread","id","name","type","size","file","File","describe","cleanupPortal","beforeEach","global","URL","createObjectURL","revokeObjectURL","mockReset","afterEach","it","_renderWithProviders","isOpen","onClose","attachment","container","rerender","expect","toBeEmptyDOMElement","_asyncToGenerator","_regeneratorRuntime","mark","_callee","wrap","_context","prev","next","url_original","getByAltText","toHaveAttribute","stop","_callee2","_context2","getByText","toBeInTheDocument","_callee3","_context3","_callee4","_context4","keyDown","document","key","toHaveBeenCalledTimes","click","querySelector","_callee5","_context5","_callee6","_context6","_callee7","_context7","url_thumbnail","_callee8","_context8","mockResolvedValue","toHaveBeenCalled","_callee9","_context9","_callee0","_container$firstEleme","_renderWithProviders2","backdrop","_context0","firstElementChild"],"sources":["../../../../src/components/atoms/AttachmentPreviewModal/AttachmentPreviewModal.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils'\nimport { ensurePortalRoot } from '../../../test/portalRoot'\nimport type { AttachmentFile } from '../../molecules/ChatFooter/ChatFooter'\nimport { AttachmentPreviewModal } from './AttachmentPreviewModal'\nimport { downloadFileFromUrl } from '../../../utils/fileDownloadHelper'\n\njest.mock('../../../hooks/useMaiaTaskPanelZIndex', () => ({\n  useMaiaTaskPanelZIndex: () => 11112,\n}))\n\njest.mock('@projectcor/cor-commons/lib/components/spinner-lottie/SpinnerLottie', () => ({\n  SpinnerLottie: () => <div>spinner</div>,\n}))\n\njest.mock('../ImagePreview/ImagePreview', () => ({\n  ImagePreview: ({ src, alt }: { src: string; alt: string }) => <img src={src} alt={alt} />,\n}))\n\njest.mock('./ExcelPreview', () => ({\n  ExcelPreview: () => <div>excel-preview</div>,\n}))\n\njest.mock('./WordPreview', () => ({\n  WordPreview: () => <div>word-preview</div>,\n}))\n\njest.mock('./PptPreview', () => ({\n  PptPreview: () => <div>ppt-preview</div>,\n}))\n\njest.mock('../MaiaStreamdown', () => ({\n  MaiaStreamdown: ({ children }: { children: string }) => <div>{children}</div>,\n}))\n\njest.mock('../../../utils/fileDownloadHelper', () => ({\n  downloadFileFromUrl: jest.fn(),\n}))\n\nconst downloadFileFromUrlMock = downloadFileFromUrl as jest.Mock\n\nconst buildAttachment = (overrides: Partial<AttachmentFile> = {}): AttachmentFile => ({\n  id: 'file-1',\n  name: 'photo.png',\n  type: 'image/png',\n  size: 100,\n  file: new File([], 'photo.png', { type: 'image/png' }),\n  ...overrides,\n})\n\ndescribe('AttachmentPreviewModal', () => {\n  let cleanupPortal: () => void\n\n  beforeEach(() => {\n    cleanupPortal = ensurePortalRoot('modal-root-actions')\n    global.URL.createObjectURL = jest.fn(() => 'blob:preview-test')\n    global.URL.revokeObjectURL = jest.fn()\n    downloadFileFromUrlMock.mockReset()\n  })\n\n  afterEach(() => {\n    cleanupPortal()\n  })\n\n  it('returns null when closed or without portal root', () => {\n    const { container, rerender } = renderWithProviders(\n      <AttachmentPreviewModal isOpen={false} onClose={jest.fn()} attachment={buildAttachment()} />\n    )\n\n    expect(container).toBeEmptyDOMElement()\n\n    cleanupPortal()\n    rerender(<AttachmentPreviewModal isOpen onClose={jest.fn()} attachment={buildAttachment()} />)\n    expect(container).toBeEmptyDOMElement()\n\n    cleanupPortal = ensurePortalRoot('modal-root-actions')\n  })\n\n  it('renders an image preview from url_original', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({ url_original: 'https://cdn.test/photo.png' })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByAltText('photo.png')).toHaveAttribute('src', 'https://cdn.test/photo.png')\n    })\n  })\n\n  it('renders text content for local txt files', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'notes.txt',\n          type: 'text/plain',\n          file: new File(['hello preview'], 'notes.txt', { type: 'text/plain' }),\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByText('hello preview')).toBeInTheDocument()\n    })\n  })\n\n  it('shows unsupported message for unknown file types', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'archive.zip',\n          type: 'application/zip',\n          file: new File(['zip'], 'archive.zip', { type: 'application/zip' }),\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByText('chat.attachmentPreviewModal.unsupportedFileMessage')).toBeInTheDocument()\n      expect(screen.getByText('archive.zip')).toBeInTheDocument()\n    })\n  })\n\n  it('closes on escape and from the header button', async () => {\n    const onClose = jest.fn()\n\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={onClose}\n        attachment={buildAttachment({ url_original: 'https://cdn.test/photo.png' })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByAltText('photo.png')).toBeInTheDocument()\n    })\n\n    fireEvent.keyDown(document, { key: 'Escape' })\n    expect(onClose).toHaveBeenCalledTimes(1)\n\n    fireEvent.click(document.querySelector('button[data-icon-only=\"true\"]') as HTMLButtonElement)\n    expect(onClose).toHaveBeenCalledTimes(2)\n  })\n\n  it('renders pdf preview from a local file blob', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'brief.pdf',\n          type: 'application/pdf',\n          file: new File(['pdf'], 'brief.pdf', { type: 'application/pdf' }),\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(document.querySelector('iframe[title=\"brief.pdf\"]')).toHaveAttribute('src', 'blob:preview-test')\n    })\n  })\n\n  it('renders markdown content for local md files', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'notes.md',\n          type: 'text/markdown',\n          file: new File(['# Title'], 'notes.md', { type: 'text/markdown' }),\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByText('# Title')).toBeInTheDocument()\n    })\n  })\n\n  it('uses thumbnail url when original image url is missing', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({ url_thumbnail: 'https://cdn.test/thumb.png' })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByAltText('photo.png')).toHaveAttribute('src', 'https://cdn.test/thumb.png')\n    })\n  })\n\n  it('downloads remote files and renders excel preview', async () => {\n    downloadFileFromUrlMock.mockResolvedValue(\n      new File(['excel'], 'sheet.xlsx', {\n        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n      })\n    )\n\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'sheet',\n          type: 'xlsx',\n          file: undefined as unknown as File,\n          url_original: 'https://cdn.test/sheet.xlsx',\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(downloadFileFromUrlMock).toHaveBeenCalled()\n      expect(screen.getByText('excel-preview')).toBeInTheDocument()\n    })\n  })\n\n  it('renders office previews from url_original', async () => {\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'brief.docx',\n          type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n          file: undefined as unknown as File,\n          url_original: 'https://cdn.test/brief.docx',\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByText('word-preview')).toBeInTheDocument()\n    })\n\n    cleanupPortal()\n    cleanupPortal = ensurePortalRoot('modal-root-actions')\n\n    renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={jest.fn()}\n        attachment={buildAttachment({\n          name: 'deck.pptx',\n          type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n          file: undefined as unknown as File,\n          url_original: 'https://cdn.test/deck.pptx',\n        })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByText('ppt-preview')).toBeInTheDocument()\n    })\n  })\n\n  it('closes when clicking the backdrop', async () => {\n    const onClose = jest.fn()\n\n    const { container } = renderWithProviders(\n      <AttachmentPreviewModal\n        isOpen\n        onClose={onClose}\n        attachment={buildAttachment({ url_original: 'https://cdn.test/photo.png' })}\n      />\n    )\n\n    await waitFor(() => {\n      expect(screen.getByAltText('photo.png')).toBeInTheDocument()\n    })\n\n    const backdrop = container.firstElementChild?.firstElementChild as HTMLElement\n    fireEvent.click(backdrop)\n\n    expect(onClose).toHaveBeenCalled()\n  })\n})\n"],"mappings":";;;;;AAAA,SAASA,SAAS,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,OAAO,QAAQ,0BAA0B;AAC1F,SAASC,gBAAgB,QAAQ,0BAA0B;AAE3D,SAASC,sBAAsB,QAAQ,0BAA0B;AACjE,SAASC,mBAAmB,QAAQ,mCAAmC;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAEvEC,IAAI,CAACC,IAAI,CAAC,uCAAuC,EAAE;EAAA,OAAO;IACxDC,sBAAsB,EAAE,SAAxBA,sBAAsBA,CAAA;MAAA,OAAQ,KAAK;IAAA;EACrC,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACC,IAAI,CAAC,qEAAqE,EAAE;EAAA,OAAO;IACtFE,aAAa,EAAE,SAAfA,aAAaA,CAAA;MAAA,oBAAQJ,IAAA;QAAAK,QAAA,EAAK;MAAO,CAAK,CAAC;IAAA;EACzC,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,8BAA8B,EAAE;EAAA,OAAO;IAC/CI,YAAY,EAAE,SAAdA,YAAYA,CAAAC,IAAA;MAAA,IAAKC,GAAG,GAAAD,IAAA,CAAHC,GAAG;QAAEC,GAAG,GAAAF,IAAA,CAAHE,GAAG;MAAA,oBAAqCT,IAAA;QAAKQ,GAAG,EAAEA,GAAI;QAACC,GAAG,EAAEA;MAAI,CAAE,CAAC;IAAA;EAC3F,CAAC;AAAA,CAAC,CAAC;AAEHR,IAAI,CAACC,IAAI,CAAC,gBAAgB,EAAE;EAAA,OAAO;IACjCQ,YAAY,EAAE,SAAdA,YAAYA,CAAA;MAAA,oBAAQV,IAAA;QAAAK,QAAA,EAAK;MAAa,CAAK,CAAC;IAAA;EAC9C,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,eAAe,EAAE;EAAA,OAAO;IAChCS,WAAW,EAAE,SAAbA,WAAWA,CAAA;MAAA,oBAAQX,IAAA;QAAAK,QAAA,EAAK;MAAY,CAAK,CAAC;IAAA;EAC5C,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,cAAc,EAAE;EAAA,OAAO;IAC/BU,UAAU,EAAE,SAAZA,UAAUA,CAAA;MAAA,oBAAQZ,IAAA;QAAAK,QAAA,EAAK;MAAW,CAAK,CAAC;IAAA;EAC1C,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,mBAAmB,EAAE;EAAA,OAAO;IACpCW,cAAc,EAAE,SAAhBA,cAAcA,CAAAC,KAAA;MAAA,IAAKT,QAAQ,GAAAS,KAAA,CAART,QAAQ;MAAA,oBAA6BL,IAAA;QAAAK,QAAA,EAAMA;MAAQ,CAAM,CAAC;IAAA;EAC/E,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,mCAAmC,EAAE;EAAA,OAAO;IACpDJ,mBAAmB,EAAEG,IAAI,CAACc,EAAE,CAAC;EAC/B,CAAC;AAAA,CAAC,CAAC;AAEH,IAAMC,uBAAuB,GAAGlB,mBAAgC;AAEhE,IAAMmB,eAAe,GAAG,SAAlBA,eAAeA,CAAA;EAAA,IAAIC,SAAkC,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAAA,OAAAG,aAAA;IAC9DC,EAAE,EAAE,QAAQ;IACZC,IAAI,EAAE,WAAW;IACjBC,IAAI,EAAE,WAAW;IACjBC,IAAI,EAAE,GAAG;IACTC,IAAI,EAAE,IAAIC,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE;MAAEH,IAAI,EAAE;IAAY,CAAC;EAAC,GACnDP,SAAS;AAAA,CACZ;AAEFW,QAAQ,CAAC,wBAAwB,EAAE,YAAM;EACvC,IAAIC,aAAyB;EAE7BC,UAAU,CAAC,YAAM;IACfD,aAAa,GAAGlC,gBAAgB,CAAC,oBAAoB,CAAC;IACtDoC,MAAM,CAACC,GAAG,CAACC,eAAe,GAAGjC,IAAI,CAACc,EAAE,CAAC;MAAA,OAAM,mBAAmB;IAAA,EAAC;IAC/DiB,MAAM,CAACC,GAAG,CAACE,eAAe,GAAGlC,IAAI,CAACc,EAAE,CAAC,CAAC;IACtCC,uBAAuB,CAACoB,SAAS,CAAC,CAAC;EACrC,CAAC,CAAC;EAEFC,SAAS,CAAC,YAAM;IACdP,aAAa,CAAC,CAAC;EACjB,CAAC,CAAC;EAEFQ,EAAE,CAAC,iDAAiD,EAAE,YAAM;IAC1D,IAAAC,oBAAA,GAAgC9C,mBAAmB,cACjDO,IAAA,CAACH,sBAAsB;QAAC2C,MAAM,EAAE,KAAM;QAACC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;QAAC2B,UAAU,EAAEzB,eAAe,CAAC;MAAE,CAAE,CAC7F,CAAC;MAFO0B,SAAS,GAAAJ,oBAAA,CAATI,SAAS;MAAEC,QAAQ,GAAAL,oBAAA,CAARK,QAAQ;IAI3BC,MAAM,CAACF,SAAS,CAAC,CAACG,mBAAmB,CAAC,CAAC;IAEvChB,aAAa,CAAC,CAAC;IACfc,QAAQ,cAAC5C,IAAA,CAACH,sBAAsB;MAAC2C,MAAM;MAACC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;MAAC2B,UAAU,EAAEzB,eAAe,CAAC;IAAE,CAAE,CAAC,CAAC;IAC9F4B,MAAM,CAACF,SAAS,CAAC,CAACG,mBAAmB,CAAC,CAAC;IAEvChB,aAAa,GAAGlC,gBAAgB,CAAC,oBAAoB,CAAC;EACxD,CAAC,CAAC;EAEF0C,EAAE,CAAC,4CAA4C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAC,QAAA;IAAA,OAAAF,mBAAA,CAAAG,IAAA,WAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAC/C7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAAEsC,YAAY,EAAE;YAA6B,CAAC;UAAE,CAC7E,CACH,CAAC;UAAAH,QAAA,CAAAE,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAAC8D,YAAY,CAAC,WAAW,CAAC,CAAC,CAACC,eAAe,CAAC,KAAK,EAAE,4BAA4B,CAAC;UAC/F,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAL,QAAA,CAAAM,IAAA;MAAA;IAAA,GAAAR,OAAA;EAAA,CACH,GAAC;EAEFZ,EAAE,CAAC,0CAA0C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAU,SAAA;IAAA,OAAAX,mBAAA,CAAAG,IAAA,WAAAS,SAAA;MAAA,kBAAAA,SAAA,CAAAP,IAAA,GAAAO,SAAA,CAAAN,IAAA;QAAA;UAC7C7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,WAAW;cACjBC,IAAI,EAAE,YAAY;cAClBE,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC,eAAe,CAAC,EAAE,WAAW,EAAE;gBAAEH,IAAI,EAAE;cAAa,CAAC;YACvE,CAAC;UAAE,CACJ,CACH,CAAC;UAAAmC,SAAA,CAAAN,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,eAAe,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UAC/D,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAF,SAAA,CAAAF,IAAA;MAAA;IAAA,GAAAC,QAAA;EAAA,CACH,GAAC;EAEFrB,EAAE,CAAC,kDAAkD,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAc,SAAA;IAAA,OAAAf,mBAAA,CAAAG,IAAA,WAAAa,SAAA;MAAA,kBAAAA,SAAA,CAAAX,IAAA,GAAAW,SAAA,CAAAV,IAAA;QAAA;UACrD7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,aAAa;cACnBC,IAAI,EAAE,iBAAiB;cACvBE,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,aAAa,EAAE;gBAAEH,IAAI,EAAE;cAAkB,CAAC;YACpE,CAAC;UAAE,CACJ,CACH,CAAC;UAAAuC,SAAA,CAAAV,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,oDAAoD,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;YAClGjB,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,aAAa,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UAC7D,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAE,SAAA,CAAAN,IAAA;MAAA;IAAA,GAAAK,QAAA;EAAA,CACH,GAAC;EAEFzB,EAAE,CAAC,6CAA6C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAgB,SAAA;IAAA,IAAAxB,OAAA;IAAA,OAAAO,mBAAA,CAAAG,IAAA,WAAAe,SAAA;MAAA,kBAAAA,SAAA,CAAAb,IAAA,GAAAa,SAAA,CAAAZ,IAAA;QAAA;UAC1Cb,OAAO,GAAGxC,IAAI,CAACc,EAAE,CAAC,CAAC;UAEzBtB,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAEA,OAAQ;YACjBC,UAAU,EAAEzB,eAAe,CAAC;cAAEsC,YAAY,EAAE;YAA6B,CAAC;UAAE,CAC7E,CACH,CAAC;UAAAW,SAAA,CAAAZ,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAAC8D,YAAY,CAAC,WAAW,CAAC,CAAC,CAACM,iBAAiB,CAAC,CAAC;UAC9D,CAAC,CAAC;QAAA;UAEFtE,SAAS,CAAC2E,OAAO,CAACC,QAAQ,EAAE;YAAEC,GAAG,EAAE;UAAS,CAAC,CAAC;UAC9CxB,MAAM,CAACJ,OAAO,CAAC,CAAC6B,qBAAqB,CAAC,CAAC,CAAC;UAExC9E,SAAS,CAAC+E,KAAK,CAACH,QAAQ,CAACI,aAAa,CAAC,+BAA+B,CAAsB,CAAC;UAC7F3B,MAAM,CAACJ,OAAO,CAAC,CAAC6B,qBAAqB,CAAC,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAJ,SAAA,CAAAR,IAAA;MAAA;IAAA,GAAAO,QAAA;EAAA,CACzC,GAAC;EAEF3B,EAAE,CAAC,4CAA4C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAwB,SAAA;IAAA,OAAAzB,mBAAA,CAAAG,IAAA,WAAAuB,SAAA;MAAA,kBAAAA,SAAA,CAAArB,IAAA,GAAAqB,SAAA,CAAApB,IAAA;QAAA;UAC/C7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,WAAW;cACjBC,IAAI,EAAE,iBAAiB;cACvBE,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE;gBAAEH,IAAI,EAAE;cAAkB,CAAC;YAClE,CAAC;UAAE,CACJ,CACH,CAAC;UAAAiD,SAAA,CAAApB,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACuB,QAAQ,CAACI,aAAa,CAAC,2BAA2B,CAAC,CAAC,CAACf,eAAe,CAAC,KAAK,EAAE,mBAAmB,CAAC;UACzG,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAiB,SAAA,CAAAhB,IAAA;MAAA;IAAA,GAAAe,QAAA;EAAA,CACH,GAAC;EAEFnC,EAAE,CAAC,6CAA6C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA0B,SAAA;IAAA,OAAA3B,mBAAA,CAAAG,IAAA,WAAAyB,SAAA;MAAA,kBAAAA,SAAA,CAAAvB,IAAA,GAAAuB,SAAA,CAAAtB,IAAA;QAAA;UAChD7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,UAAU;cAChBC,IAAI,EAAE,eAAe;cACrBE,IAAI,EAAE,IAAIC,IAAI,CAAC,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE;gBAAEH,IAAI,EAAE;cAAgB,CAAC;YACnE,CAAC;UAAE,CACJ,CACH,CAAC;UAAAmD,SAAA,CAAAtB,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,SAAS,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UACzD,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAc,SAAA,CAAAlB,IAAA;MAAA;IAAA,GAAAiB,QAAA;EAAA,CACH,GAAC;EAEFrC,EAAE,CAAC,uDAAuD,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA4B,SAAA;IAAA,OAAA7B,mBAAA,CAAAG,IAAA,WAAA2B,SAAA;MAAA,kBAAAA,SAAA,CAAAzB,IAAA,GAAAyB,SAAA,CAAAxB,IAAA;QAAA;UAC1D7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAAE8D,aAAa,EAAE;YAA6B,CAAC;UAAE,CAC9E,CACH,CAAC;UAAAD,SAAA,CAAAxB,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAAC8D,YAAY,CAAC,WAAW,CAAC,CAAC,CAACC,eAAe,CAAC,KAAK,EAAE,4BAA4B,CAAC;UAC/F,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAqB,SAAA,CAAApB,IAAA;MAAA;IAAA,GAAAmB,QAAA;EAAA,CACH,GAAC;EAEFvC,EAAE,CAAC,kDAAkD,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA+B,SAAA;IAAA,OAAAhC,mBAAA,CAAAG,IAAA,WAAA8B,SAAA;MAAA,kBAAAA,SAAA,CAAA5B,IAAA,GAAA4B,SAAA,CAAA3B,IAAA;QAAA;UACrDtC,uBAAuB,CAACkE,iBAAiB,CACvC,IAAItD,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,YAAY,EAAE;YAChCH,IAAI,EAAE;UACR,CAAC,CACH,CAAC;UAEDhC,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,OAAO;cACbC,IAAI,EAAE,MAAM;cACZE,IAAI,EAAEN,SAA4B;cAClCkC,YAAY,EAAE;YAChB,CAAC;UAAE,CACJ,CACH,CAAC;UAAA0B,SAAA,CAAA3B,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAAC7B,uBAAuB,CAAC,CAACmE,gBAAgB,CAAC,CAAC;YAClDtC,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,eAAe,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UAC/D,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAmB,SAAA,CAAAvB,IAAA;MAAA;IAAA,GAAAsB,QAAA;EAAA,CACH,GAAC;EAEF1C,EAAE,CAAC,2CAA2C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAmC,SAAA;IAAA,OAAApC,mBAAA,CAAAG,IAAA,WAAAkC,SAAA;MAAA,kBAAAA,SAAA,CAAAhC,IAAA,GAAAgC,SAAA,CAAA/B,IAAA;QAAA;UAC9C7D,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,YAAY;cAClBC,IAAI,EAAE,yEAAyE;cAC/EE,IAAI,EAAEN,SAA4B;cAClCkC,YAAY,EAAE;YAChB,CAAC;UAAE,CACJ,CACH,CAAC;UAAA8B,SAAA,CAAA/B,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,cAAc,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UAC9D,CAAC,CAAC;QAAA;UAEFhC,aAAa,CAAC,CAAC;UACfA,aAAa,GAAGlC,gBAAgB,CAAC,oBAAoB,CAAC;UAEtDH,mBAAmB,cACjBO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAExC,IAAI,CAACc,EAAE,CAAC,CAAE;YACnB2B,UAAU,EAAEzB,eAAe,CAAC;cAC1BO,IAAI,EAAE,WAAW;cACjBC,IAAI,EAAE,2EAA2E;cACjFE,IAAI,EAAEN,SAA4B;cAClCkC,YAAY,EAAE;YAChB,CAAC;UAAE,CACJ,CACH,CAAC;UAAA8B,SAAA,CAAA/B,IAAA;UAAA,OAEK3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAACmE,SAAS,CAAC,aAAa,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;UAC7D,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAuB,SAAA,CAAA3B,IAAA;MAAA;IAAA,GAAA0B,QAAA;EAAA,CACH,GAAC;EAEF9C,EAAE,CAAC,mCAAmC,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAqC,SAAA;IAAA,IAAAC,qBAAA;IAAA,IAAA9C,OAAA,EAAA+C,qBAAA,EAAA7C,SAAA,EAAA8C,QAAA;IAAA,OAAAzC,mBAAA,CAAAG,IAAA,WAAAuC,SAAA;MAAA,kBAAAA,SAAA,CAAArC,IAAA,GAAAqC,SAAA,CAAApC,IAAA;QAAA;UAChCb,OAAO,GAAGxC,IAAI,CAACc,EAAE,CAAC,CAAC;UAAAyE,qBAAA,GAEH/F,mBAAmB,cACvCO,IAAA,CAACH,sBAAsB;YACrB2C,MAAM;YACNC,OAAO,EAAEA,OAAQ;YACjBC,UAAU,EAAEzB,eAAe,CAAC;cAAEsC,YAAY,EAAE;YAA6B,CAAC;UAAE,CAC7E,CACH,CAAC,EANOZ,SAAS,GAAA6C,qBAAA,CAAT7C,SAAS;UAAA+C,SAAA,CAAApC,IAAA;UAAA,OAQX3D,OAAO,CAAC,YAAM;YAClBkD,MAAM,CAACnD,MAAM,CAAC8D,YAAY,CAAC,WAAW,CAAC,CAAC,CAACM,iBAAiB,CAAC,CAAC;UAC9D,CAAC,CAAC;QAAA;UAEI2B,QAAQ,IAAAF,qBAAA,GAAG5C,SAAS,CAACgD,iBAAiB,cAAAJ,qBAAA,uBAA3BA,qBAAA,CAA6BI,iBAAiB;UAC/DnG,SAAS,CAAC+E,KAAK,CAACkB,QAAQ,CAAC;UAEzB5C,MAAM,CAACJ,OAAO,CAAC,CAAC0C,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAO,SAAA,CAAAhC,IAAA;MAAA;IAAA,GAAA4B,QAAA;EAAA,CACnC,GAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/components/atoms/AttachmentPreviewModal/ExcelPreview.spec.js

@@ -0,0 +1,80 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { ExcelPreview } from './ExcelPreview';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('xlsx', function () {
+  return {
+    read: jest.fn(function () {
+      return {
+        SheetNames: ['Sheet1', 'Sheet2'],
+        Sheets: {
+          Sheet1: {},
+          Sheet2: {}
+        }
+      };
+    }),
+    utils: {
+      sheet_to_json: jest.fn(function (_sheet, options) {
+        if ((options === null || options === void 0 ? void 0 : options.header) === 1) {
+          return [['Name', 'Value'], ['Alpha', '1']];
+        }
+        return [];
+      })
+    }
+  };
+});
+describe('ExcelPreview', function () {
+  it('renders spreadsheet rows from a local file', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(ExcelPreview, {
+            fileName: "report.xlsx",
+            file: new File(['xlsx'], 'report.xlsx', {
+              type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            })
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            expect(screen.getByText('Alpha')).toBeInTheDocument();
+            expect(screen.getByText('chat.attachmentPreviewModal.excel.sheetSelectorLabel')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('switches sheets from the selector', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(ExcelPreview, {
+            fileName: "report.xlsx",
+            file: new File(['xlsx'], 'report.xlsx', {
+              type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            })
+          }));
+          _context2.next = 1;
+          return waitFor(function () {
+            expect(screen.getByRole('combobox')).toBeInTheDocument();
+          });
+        case 1:
+          fireEvent.change(screen.getByRole('combobox'), {
+            target: {
+              value: 'Sheet2'
+            }
+          });
+          _context2.next = 2;
+          return waitFor(function () {
+            expect(screen.getByText('Alpha')).toBeInTheDocument();
+          });
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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