@projectcor/maia-components 2.38.0 → 2.38.2

package/lib/components/molecules/ContextMentionInput/ContextMentionInput.spec.js

@@ -0,0 +1,84 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ContextMentionInput } from './ContextMentionInput';
+import { jsx as _jsx } from "react/jsx-runtime";
+var editorText = 'hola @Ana';
+jest.mock('../../atoms/ContextMentionEditor', function () {
+  var React = jest.requireActual('react');
+  return {
+    ContextMentionEditor: React.forwardRef(function (props, ref) {
+      React.useImperativeHandle(ref, function () {
+        return {
+          serialize: function serialize() {
+            return {
+              text: editorText,
+              mentions: editorText.includes('@Ana') ? [{
+                type: 'user',
+                id: '1',
+                name: 'Ana'
+              }] : [],
+              slashCommands: []
+            };
+          },
+          clear: jest.fn()
+        };
+      });
+      return React.createElement('div', {
+        role: 'textbox',
+        'aria-label': props.placeholder || 'mention-input',
+        onKeyDown: props.onKeyDown
+      });
+    })
+  };
+});
+jest.mock('../../../hooks/useMentionPopover', function () {
+  return {
+    useMentionPopover: function useMentionPopover() {
+      return {
+        popoverOpen: false,
+        resetMentionOpenTracking: jest.fn(),
+        handleTrigger: jest.fn(),
+        handleKeyDown: function handleKeyDown() {
+          return false;
+        },
+        popoverNode: null
+      };
+    }
+  };
+});
+describe('ContextMentionInput', function () {
+  beforeEach(function () {
+    editorText = 'hola @Ana';
+  });
+  it('sends text and mentions on Enter', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionInput, {
+      placeholder: "Escrib\xED",
+      onSendMessage: onSendMessage
+    }));
+    fireEvent.keyDown(screen.getByRole('textbox'), {
+      key: 'Enter'
+    });
+    expect(onSendMessage).toHaveBeenCalledWith('hola @Ana', [{
+      type: 'user',
+      id: '1',
+      name: 'Ana'
+    }]);
+  });
+  it('does not send on Shift+Enter or empty text', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionInput, {
+      onSendMessage: onSendMessage
+    }));
+    fireEvent.keyDown(screen.getByRole('textbox'), {
+      key: 'Enter',
+      shiftKey: true
+    });
+    expect(onSendMessage).not.toHaveBeenCalled();
+    editorText = '   ';
+    fireEvent.keyDown(screen.getByRole('textbox'), {
+      key: 'Enter'
+    });
+    expect(onSendMessage).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmaXJlRXZlbnQiLCJyZW5kZXJXaXRoUHJvdmlkZXJzIiwic2NyZWVuIiwiQ29udGV4dE1lbnRpb25JbnB1dCIsImpzeCIsIl9qc3giLCJlZGl0b3JUZXh0IiwiamVzdCIsIm1vY2siLCJSZWFjdCIsInJlcXVpcmVBY3R1YWwiLCJDb250ZXh0TWVudGlvbkVkaXRvciIsImZvcndhcmRSZWYiLCJwcm9wcyIsInJlZiIsInVzZUltcGVyYXRpdmVIYW5kbGUiLCJzZXJpYWxpemUiLCJ0ZXh0IiwibWVudGlvbnMiLCJpbmNsdWRlcyIsInR5cGUiLCJpZCIsIm5hbWUiLCJzbGFzaENvbW1hbmRzIiwiY2xlYXIiLCJmbiIsImNyZWF0ZUVsZW1lbnQiLCJyb2xlIiwicGxhY2Vob2xkZXIiLCJvbktleURvd24iLCJ1c2VNZW50aW9uUG9wb3ZlciIsInBvcG92ZXJPcGVuIiwicmVzZXRNZW50aW9uT3BlblRyYWNraW5nIiwiaGFuZGxlVHJpZ2dlciIsImhhbmRsZUtleURvd24iLCJwb3BvdmVyTm9kZSIsImRlc2NyaWJlIiwiYmVmb3JlRWFjaCIsIml0Iiwib25TZW5kTWVzc2FnZSIsImtleURvd24iLCJnZXRCeVJvbGUiLCJrZXkiLCJleHBlY3QiLCJ0b0hhdmVCZWVuQ2FsbGVkV2l0aCIsInNoaWZ0S2V5Iiwibm90IiwidG9IYXZlQmVlbkNhbGxlZCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL21vbGVjdWxlcy9Db250ZXh0TWVudGlvbklucHV0L0NvbnRleHRNZW50aW9uSW5wdXQuc3BlYy50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZmlyZUV2ZW50LCByZW5kZXJXaXRoUHJvdmlkZXJzLCBzY3JlZW4gfSBmcm9tICcuLi8uLi8uLi90ZXN0L3Rlc3QtdXRpbHMnXG5pbXBvcnQgeyBDb250ZXh0TWVudGlvbklucHV0IH0gZnJvbSAnLi9Db250ZXh0TWVudGlvbklucHV0J1xuXG5sZXQgZWRpdG9yVGV4dCA9ICdob2xhIEBBbmEnXG5cbmplc3QubW9jaygnLi4vLi4vYXRvbXMvQ29udGV4dE1lbnRpb25FZGl0b3InLCAoKSA9PiB7XG4gIGNvbnN0IFJlYWN0ID0gamVzdC5yZXF1aXJlQWN0dWFsKCdyZWFjdCcpXG4gIHJldHVybiB7XG4gICAgQ29udGV4dE1lbnRpb25FZGl0b3I6IFJlYWN0LmZvcndhcmRSZWYoXG4gICAgICAocHJvcHM6IHsgcGxhY2Vob2xkZXI/OiBzdHJpbmc7IG9uS2V5RG93bj86IChldmVudDogdW5rbm93bikgPT4gdm9pZCB9LCByZWYpID0+IHtcbiAgICAgICAgUmVhY3QudXNlSW1wZXJhdGl2ZUhhbmRsZShyZWYsICgpID0+ICh7XG4gICAgICAgICAgc2VyaWFsaXplOiAoKSA9PiAoe1xuICAgICAgICAgICAgdGV4dDogZWRpdG9yVGV4dCxcbiAgICAgICAgICAgIG1lbnRpb25zOiBlZGl0b3JUZXh0LmluY2x1ZGVzKCdAQW5hJykgPyBbeyB0eXBlOiAndXNlcicsIGlkOiAnMScsIG5hbWU6ICdBbmEnIH1dIDogW10sXG4gICAgICAgICAgICBzbGFzaENvbW1hbmRzOiBbXSxcbiAgICAgICAgICB9KSxcbiAgICAgICAgICBjbGVhcjogamVzdC5mbigpLFxuICAgICAgICB9KSlcblxuICAgICAgICByZXR1cm4gUmVhY3QuY3JlYXRlRWxlbWVudCgnZGl2Jywge1xuICAgICAgICAgIHJvbGU6ICd0ZXh0Ym94JyxcbiAgICAgICAgICAnYXJpYS1sYWJlbCc6IHByb3BzLnBsYWNlaG9sZGVyIHx8ICdtZW50aW9uLWlucHV0JyxcbiAgICAgICAgICBvbktleURvd246IHByb3BzLm9uS2V5RG93bixcbiAgICAgICAgfSlcbiAgICAgIH1cbiAgICApLFxuICB9XG59KVxuXG5qZXN0Lm1vY2soJy4uLy4uLy4uL2hvb2tzL3VzZU1lbnRpb25Qb3BvdmVyJywgKCkgPT4gKHtcbiAgdXNlTWVudGlvblBvcG92ZXI6ICgpID0+ICh7XG4gICAgcG9wb3Zlck9wZW46IGZhbHNlLFxuICAgIHJlc2V0TWVudGlvbk9wZW5UcmFja2luZzogamVzdC5mbigpLFxuICAgIGhhbmRsZVRyaWdnZXI6IGplc3QuZm4oKSxcbiAgICBoYW5kbGVLZXlEb3duOiAoKSA9PiBmYWxzZSxcbiAgICBwb3BvdmVyTm9kZTogbnVsbCxcbiAgfSksXG59KSlcblxuZGVzY3JpYmUoJ0NvbnRleHRNZW50aW9uSW5wdXQnLCAoKSA9PiB7XG4gIGJlZm9yZUVhY2goKCkgPT4ge1xuICAgIGVkaXRvclRleHQgPSAnaG9sYSBAQW5hJ1xuICB9KVxuXG4gIGl0KCdzZW5kcyB0ZXh0IGFuZCBtZW50aW9ucyBvbiBFbnRlcicsICgpID0+IHtcbiAgICBjb25zdCBvblNlbmRNZXNzYWdlID0gamVzdC5mbigpXG4gICAgcmVuZGVyV2l0aFByb3ZpZGVycyg8Q29udGV4dE1lbnRpb25JbnB1dCBwbGFjZWhvbGRlcj1cIkVzY3JpYsOtXCIgb25TZW5kTWVzc2FnZT17b25TZW5kTWVzc2FnZX0gLz4pXG5cbiAgICBmaXJlRXZlbnQua2V5RG93bihzY3JlZW4uZ2V0QnlSb2xlKCd0ZXh0Ym94JyksIHsga2V5OiAnRW50ZXInIH0pXG5cbiAgICBleHBlY3Qob25TZW5kTWVzc2FnZSkudG9IYXZlQmVlbkNhbGxlZFdpdGgoJ2hvbGEgQEFuYScsIFt7IHR5cGU6ICd1c2VyJywgaWQ6ICcxJywgbmFtZTogJ0FuYScgfV0pXG4gIH0pXG5cbiAgaXQoJ2RvZXMgbm90IHNlbmQgb24gU2hpZnQrRW50ZXIgb3IgZW1wdHkgdGV4dCcsICgpID0+IHtcbiAgICBjb25zdCBvblNlbmRNZXNzYWdlID0gamVzdC5mbigpXG4gICAgcmVuZGVyV2l0aFByb3ZpZGVycyg8Q29udGV4dE1lbnRpb25JbnB1dCBvblNlbmRNZXNzYWdlPXtvblNlbmRNZXNzYWdlfSAvPilcblxuICAgIGZpcmVFdmVudC5rZXlEb3duKHNjcmVlbi5nZXRCeVJvbGUoJ3RleHRib3gnKSwgeyBrZXk6ICdFbnRlcicsIHNoaWZ0S2V5OiB0cnVlIH0pXG4gICAgZXhwZWN0KG9uU2VuZE1lc3NhZ2UpLm5vdC50b0hhdmVCZWVuQ2FsbGVkKClcblxuICAgIGVkaXRvclRleHQgPSAnICAgJ1xuICAgIGZpcmVFdmVudC5rZXlEb3duKHNjcmVlbi5nZXRCeVJvbGUoJ3RleHRib3gnKSwgeyBrZXk6ICdFbnRlcicgfSlcbiAgICBleHBlY3Qob25TZW5kTWVzc2FnZSkubm90LnRvSGF2ZUJlZW5DYWxsZWQoKVxuICB9KVxufSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsU0FBUyxFQUFFQyxtQkFBbUIsRUFBRUMsTUFBTSxRQUFRLDBCQUEwQjtBQUNqRixTQUFTQyxtQkFBbUIsUUFBUSx1QkFBdUI7QUFBQSxTQUFBQyxHQUFBLElBQUFDLElBQUE7QUFFM0QsSUFBSUMsVUFBVSxHQUFHLFdBQVc7QUFFNUJDLElBQUksQ0FBQ0MsSUFBSSxDQUFDLGtDQUFrQyxFQUFFLFlBQU07RUFDbEQsSUFBTUMsS0FBSyxHQUFHRixJQUFJLENBQUNHLGFBQWEsQ0FBQyxPQUFPLENBQUM7RUFDekMsT0FBTztJQUNMQyxvQkFBb0IsRUFBRUYsS0FBSyxDQUFDRyxVQUFVLENBQ3BDLFVBQUNDLEtBQXFFLEVBQUVDLEdBQUcsRUFBSztNQUM5RUwsS0FBSyxDQUFDTSxtQkFBbUIsQ0FBQ0QsR0FBRyxFQUFFO1FBQUEsT0FBTztVQUNwQ0UsU0FBUyxFQUFFLFNBQVhBLFNBQVNBLENBQUE7WUFBQSxPQUFTO2NBQ2hCQyxJQUFJLEVBQUVYLFVBQVU7Y0FDaEJZLFFBQVEsRUFBRVosVUFBVSxDQUFDYSxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztnQkFBRUMsSUFBSSxFQUFFLE1BQU07Z0JBQUVDLEVBQUUsRUFBRSxHQUFHO2dCQUFFQyxJQUFJLEVBQUU7Y0FBTSxDQUFDLENBQUMsR0FBRyxFQUFFO2NBQ3JGQyxhQUFhLEVBQUU7WUFDakIsQ0FBQztVQUFBLENBQUM7VUFDRkMsS0FBSyxFQUFFakIsSUFBSSxDQUFDa0IsRUFBRSxDQUFDO1FBQ2pCLENBQUM7TUFBQSxDQUFDLENBQUM7TUFFSCxPQUFPaEIsS0FBSyxDQUFDaUIsYUFBYSxDQUFDLEtBQUssRUFBRTtRQUNoQ0MsSUFBSSxFQUFFLFNBQVM7UUFDZixZQUFZLEVBQUVkLEtBQUssQ0FBQ2UsV0FBVyxJQUFJLGVBQWU7UUFDbERDLFNBQVMsRUFBRWhCLEtBQUssQ0FBQ2dCO01BQ25CLENBQUMsQ0FBQztJQUNKLENBQ0Y7RUFDRixDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBRUZ0QixJQUFJLENBQUNDLElBQUksQ0FBQyxrQ0FBa0MsRUFBRTtFQUFBLE9BQU87SUFDbkRzQixpQkFBaUIsRUFBRSxTQUFuQkEsaUJBQWlCQSxDQUFBO01BQUEsT0FBUztRQUN4QkMsV0FBVyxFQUFFLEtBQUs7UUFDbEJDLHdCQUF3QixFQUFFekIsSUFBSSxDQUFDa0IsRUFBRSxDQUFDLENBQUM7UUFDbkNRLGFBQWEsRUFBRTFCLElBQUksQ0FBQ2tCLEVBQUUsQ0FBQyxDQUFDO1FBQ3hCUyxhQUFhLEVBQUUsU0FBZkEsYUFBYUEsQ0FBQTtVQUFBLE9BQVEsS0FBSztRQUFBO1FBQzFCQyxXQUFXLEVBQUU7TUFDZixDQUFDO0lBQUE7RUFDSCxDQUFDO0FBQUEsQ0FBQyxDQUFDO0FBRUhDLFFBQVEsQ0FBQyxxQkFBcUIsRUFBRSxZQUFNO0VBQ3BDQyxVQUFVLENBQUMsWUFBTTtJQUNmL0IsVUFBVSxHQUFHLFdBQVc7RUFDMUIsQ0FBQyxDQUFDO0VBRUZnQyxFQUFFLENBQUMsa0NBQWtDLEVBQUUsWUFBTTtJQUMzQyxJQUFNQyxhQUFhLEdBQUdoQyxJQUFJLENBQUNrQixFQUFFLENBQUMsQ0FBQztJQUMvQnhCLG1CQUFtQixjQUFDSSxJQUFBLENBQUNGLG1CQUFtQjtNQUFDeUIsV0FBVyxFQUFDLFlBQVM7TUFBQ1csYUFBYSxFQUFFQTtJQUFjLENBQUUsQ0FBQyxDQUFDO0lBRWhHdkMsU0FBUyxDQUFDd0MsT0FBTyxDQUFDdEMsTUFBTSxDQUFDdUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxFQUFFO01BQUVDLEdBQUcsRUFBRTtJQUFRLENBQUMsQ0FBQztJQUVoRUMsTUFBTSxDQUFDSixhQUFhLENBQUMsQ0FBQ0ssb0JBQW9CLENBQUMsV0FBVyxFQUFFLENBQUM7TUFBRXhCLElBQUksRUFBRSxNQUFNO01BQUVDLEVBQUUsRUFBRSxHQUFHO01BQUVDLElBQUksRUFBRTtJQUFNLENBQUMsQ0FBQyxDQUFDO0VBQ25HLENBQUMsQ0FBQztFQUVGZ0IsRUFBRSxDQUFDLDRDQUE0QyxFQUFFLFlBQU07SUFDckQsSUFBTUMsYUFBYSxHQUFHaEMsSUFBSSxDQUFDa0IsRUFBRSxDQUFDLENBQUM7SUFDL0J4QixtQkFBbUIsY0FBQ0ksSUFBQSxDQUFDRixtQkFBbUI7TUFBQ29DLGFBQWEsRUFBRUE7SUFBYyxDQUFFLENBQUMsQ0FBQztJQUUxRXZDLFNBQVMsQ0FBQ3dDLE9BQU8sQ0FBQ3RDLE1BQU0sQ0FBQ3VDLFNBQVMsQ0FBQyxTQUFTLENBQUMsRUFBRTtNQUFFQyxHQUFHLEVBQUUsT0FBTztNQUFFRyxRQUFRLEVBQUU7SUFBSyxDQUFDLENBQUM7SUFDaEZGLE1BQU0sQ0FBQ0osYUFBYSxDQUFDLENBQUNPLEdBQUcsQ0FBQ0MsZ0JBQWdCLENBQUMsQ0FBQztJQUU1Q3pDLFVBQVUsR0FBRyxLQUFLO0lBQ2xCTixTQUFTLENBQUN3QyxPQUFPLENBQUN0QyxNQUFNLENBQUN1QyxTQUFTLENBQUMsU0FBUyxDQUFDLEVBQUU7TUFBRUMsR0FBRyxFQUFFO0lBQVEsQ0FBQyxDQUFDO0lBQ2hFQyxNQUFNLENBQUNKLGFBQWEsQ0FBQyxDQUFDTyxHQUFHLENBQUNDLGdCQUFnQixDQUFDLENBQUM7RUFDOUMsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/lib/components/molecules/MessageFeedback/MessageFeedback.spec.js

@@ -0,0 +1,116 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { GlobalContextTestProvider } from '../../../test/global-context';
+import { Feedback, MessageFeedback } from './MessageFeedback';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatResponse: 'AI_CHAT_RESPONSE'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+jest.mock('../../atoms/CopyToClipboard', function () {
+  return {
+    CopyToClipboard: function CopyToClipboard(_ref) {
+      var text = _ref.text;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": "globals.copy",
+        "data-text": text,
+        children: "copy"
+      });
+    }
+  };
+});
+jest.mock('../../atoms/ActionableButton', function () {
+  return {
+    ActionableButton: function ActionableButton(_ref2) {
+      var handleClick = _ref2.handleClick,
+        tooltip = _ref2.tooltip,
+        disabled = _ref2.disabled;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        disabled: disabled,
+        onClick: handleClick,
+        children: tooltip
+      });
+    }
+  };
+});
+jest.mock('../../atoms/IconButton', function () {
+  return {
+    IconButton: function IconButton(_ref3) {
+      var handleClick = _ref3.handleClick,
+        tooltip = _ref3.tooltip;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        onClick: handleClick,
+        children: tooltip
+      });
+    }
+  };
+});
+jest.mock('../../organisms/SourcesInformation', function () {
+  return {
+    SourcesInformationModal: function SourcesInformationModal(_ref4) {
+      var onClose = _ref4.onClose;
+      return /*#__PURE__*/_jsx("div", {
+        role: "dialog",
+        children: /*#__PURE__*/_jsx("button", {
+          type: "button",
+          onClick: onClose,
+          children: "close-sources"
+        })
+      });
+    }
+  };
+});
+var renderFeedback = function renderFeedback(ui) {
+  return renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+    children: ui
+  }));
+};
+describe('MessageFeedback', function () {
+  it('sends thumbs up once and hides thumbs down', function () {
+    var handleFeedback = jest.fn();
+    renderFeedback(/*#__PURE__*/_jsx(MessageFeedback, {
+      content: "Hola",
+      handleFeedback: handleFeedback
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'feedback.thumbsUp'
+    }));
+    expect(handleFeedback).toHaveBeenCalledWith(Feedback.THUMBS_UP);
+    expect(screen.queryByRole('button', {
+      name: 'feedback.thumbsDown'
+    })).not.toBeInTheDocument();
+  });
+  it('retries the answer', function () {
+    var onRetry = jest.fn();
+    renderFeedback(/*#__PURE__*/_jsx(MessageFeedback, {
+      content: "Hola",
+      onRetry: onRetry
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.retry'
+    }));
+    expect(onRetry).toHaveBeenCalledTimes(1);
+  });
+  it('opens sources when they exist', function () {
+    renderFeedback(/*#__PURE__*/_jsx(MessageFeedback, {
+      content: "Hola",
+      sources: [{
+        source: 'doc',
+        reference: '1'
+      }]
+    }));
+    fireEvent.click(screen.getByText('feedback.sources'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","GlobalContextTestProvider","Feedback","MessageFeedback","jsx","_jsx","jest","mock","EVENTS","aiChatResponse","useEvent","fn","CopyToClipboard","_ref","text","type","children","ActionableButton","_ref2","handleClick","tooltip","disabled","onClick","IconButton","_ref3","SourcesInformationModal","_ref4","onClose","role","renderFeedback","ui","describe","it","handleFeedback","content","click","getByRole","name","expect","toHaveBeenCalledWith","THUMBS_UP","queryByRole","not","toBeInTheDocument","onRetry","toHaveBeenCalledTimes","sources","source","reference","getByText"],"sources":["../../../../src/components/molecules/MessageFeedback/MessageFeedback.spec.tsx"],"sourcesContent":["import { ReactElement } from 'react'\nimport { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider } from '../../../test/global-context'\nimport { Feedback, MessageFeedback } from './MessageFeedback'\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: { aiChatResponse: 'AI_CHAT_RESPONSE' },\n  useEvent: () => jest.fn(),\n}))\n\njest.mock('../../atoms/CopyToClipboard', () => ({\n  CopyToClipboard: ({ text }: { text: string }) => (\n    <button type=\"button\" aria-label=\"globals.copy\" data-text={text}>\n      copy\n    </button>\n  ),\n}))\n\njest.mock('../../atoms/ActionableButton', () => ({\n  ActionableButton: ({\n    handleClick,\n    tooltip,\n    disabled,\n  }: {\n    handleClick: () => void\n    tooltip: string\n    disabled?: boolean\n  }) => (\n    <button type=\"button\" aria-label={tooltip} disabled={disabled} onClick={handleClick}>\n      {tooltip}\n    </button>\n  ),\n}))\n\njest.mock('../../atoms/IconButton', () => ({\n  IconButton: ({ handleClick, tooltip }: { handleClick?: () => void; tooltip: string }) => (\n    <button type=\"button\" aria-label={tooltip} onClick={handleClick}>\n      {tooltip}\n    </button>\n  ),\n}))\n\njest.mock('../../organisms/SourcesInformation', () => ({\n  SourcesInformationModal: ({ onClose }: { onClose: () => void }) => (\n    <div role=\"dialog\">\n      <button type=\"button\" onClick={onClose}>\n        close-sources\n      </button>\n    </div>\n  ),\n}))\n\nconst renderFeedback = (ui: ReactElement) =>\n  renderWithProviders(<GlobalContextTestProvider>{ui}</GlobalContextTestProvider>)\n\ndescribe('MessageFeedback', () => {\n  it('sends thumbs up once and hides thumbs down', () => {\n    const handleFeedback = jest.fn()\n    renderFeedback(<MessageFeedback content=\"Hola\" handleFeedback={handleFeedback} />)\n\n    fireEvent.click(screen.getByRole('button', { name: 'feedback.thumbsUp' }))\n\n    expect(handleFeedback).toHaveBeenCalledWith(Feedback.THUMBS_UP)\n    expect(screen.queryByRole('button', { name: 'feedback.thumbsDown' })).not.toBeInTheDocument()\n  })\n\n  it('retries the answer', () => {\n    const onRetry = jest.fn()\n    renderFeedback(<MessageFeedback content=\"Hola\" onRetry={onRetry} />)\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.retry' }))\n\n    expect(onRetry).toHaveBeenCalledTimes(1)\n  })\n\n  it('opens sources when they exist', () => {\n    renderFeedback(<MessageFeedback content=\"Hola\" sources={[{ source: 'doc', reference: '1' }]} />)\n\n    fireEvent.click(screen.getByText('feedback.sources'))\n\n    expect(screen.getByRole('dialog')).toBeInTheDocument()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/Sidebar/Sidebar.spec.js

@@ -0,0 +1,208 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 } from '../../../test/test-utils';
+import { GlobalContextTestProvider } from '../../../test/global-context';
+import { Sidebar } from './Sidebar';
+import { jsx as _jsx } from "react/jsx-runtime";
+var chatsState = {
+  loadingChats: false,
+  chats: [],
+  deleteChat: jest.fn(),
+  updateChat: jest.fn(),
+  fetchChats: jest.fn(),
+  limit: 20,
+  offset: 0,
+  hasMoreChats: false,
+  loadMoreChats: jest.fn(),
+  isLoadingMoreChats: false,
+  unreadCount: 0,
+  setUnreadCount: jest.fn(),
+  setChatReadState: jest.fn()
+};
+jest.mock('../../../hooks/useChats', function () {
+  return {
+    useChats: function useChats() {
+      return chatsState;
+    }
+  };
+});
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      pmAiOpenConversation: 'PM_AI_OPEN_CONVERSATION',
+      pmAiNewConversation: 'PM_AI_NEW_CONVERSATION',
+      pmAiMenuEdit: 'PM_AI_MENU_EDIT',
+      pmAiMenuDelete: 'PM_AI_MENU_DELETE',
+      aiSidebarNewChat: 'AI_SIDEBAR_NEW_CHAT',
+      aiSidebarMyAgents: 'AI_SIDEBAR_MY_AGENTS',
+      aiChatSidebar: 'AI_CHAT_SIDEBAR'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+jest.mock('../../../context/cor-user', function () {
+  return {
+    CORUserRole: {
+      CLEVEL: 1,
+      DIRECTOR: 2,
+      PROJECT_MANAGER: 3,
+      COLLABORATOR: 4,
+      FREELANCER: 5,
+      CLIENT: 6
+    },
+    useUser: function useUser() {
+      return {
+        id: 99,
+        company_id: 10,
+        role_id: 3
+      };
+    }
+  };
+});
+jest.mock('../../../lang/utils', function () {
+  return {
+    mapCORLang: function mapCORLang(lang) {
+      return lang;
+    }
+  };
+});
+jest.mock('../../../store/sessions/useSessionMeta', function () {
+  return {
+    useIsSessionGenerating: function useIsSessionGenerating() {
+      return false;
+    },
+    useSessionMeta: function useSessionMeta() {
+      return null;
+    }
+  };
+});
+jest.mock('../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 1500;
+    }
+  };
+});
+jest.mock('../../atoms/FeedbackButton', function () {
+  return {
+    FeedbackButton: function FeedbackButton() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "feedback"
+      });
+    }
+  };
+});
+jest.mock('../../organisms/EditQuestionModal', function () {
+  return {
+    EditQuestionModal: function EditQuestionModal() {
+      return null;
+    }
+  };
+});
+jest.mock('../../organisms/DeleteQuestionModal', function () {
+  return {
+    DeleteQuestionModal: function DeleteQuestionModal() {
+      return null;
+    }
+  };
+});
+jest.mock('../../../services/maia/client', function () {
+  return {
+    fetchMaia: jest.fn()
+  };
+});
+jest.mock('../../../services/appcues', function () {
+  return {
+    APPCUES_EVENTS: {},
+    APPCUES_SELECTORS: {},
+    trackAppcuesEvent: jest.fn()
+  };
+});
+var sidebarProps = {
+  onGoToChat: jest.fn(),
+  onError: jest.fn(),
+  handleGoToHome: jest.fn(),
+  handleOpenMarketplace: jest.fn(),
+  handleOpenSkills: jest.fn(),
+  showNewChat: true,
+  refetchChats: false,
+  handleSetRefetchChats: jest.fn(),
+  hasError: false,
+  initialOpen: true
+};
+var renderSidebar = function renderSidebar(ui) {
+  return renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+    children: ui
+  }));
+};
+var chat = function chat(id, title) {
+  return {
+    id: id,
+    sessionExternalId: id,
+    title: title,
+    date: new Date('2026-01-01'),
+    agent: 'MAIA',
+    agentId: 1,
+    emoji: '🤖',
+    isRead: true
+  };
+};
+describe('Sidebar', function () {
+  beforeEach(function () {
+    chatsState.loadingChats = false;
+    chatsState.chats = [];
+    chatsState.unreadCount = 0;
+    sidebarProps.onGoToChat.mockClear();
+    sidebarProps.hasError = false;
+  });
+  it('shows the empty conversations state', function () {
+    renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread({}, sidebarProps)));
+    expect(screen.getByText('conversations.empty')).toBeInTheDocument();
+  });
+  it('shows the error state without chats', function () {
+    renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread(_objectSpread({}, sidebarProps), {}, {
+      hasError: true
+    })));
+    expect(screen.getByText('conversations.error')).toBeInTheDocument();
+    expect(screen.queryByText('conversations.empty')).not.toBeInTheDocument();
+  });
+  it('opens a conversation from the list', function () {
+    chatsState.chats = [chat('s1', 'Resumen del brief')];
+    chatsState.unreadCount = 4;
+    renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread({}, sidebarProps)));
+    expect(screen.getByLabelText('conversations.unreadLabel')).toHaveTextContent('4');
+    fireEvent.click(screen.getByText('Resumen del brief'));
+    expect(sidebarProps.onGoToChat).toHaveBeenCalledWith(expect.objectContaining({
+      sessionExternalId: 's1'
+    }));
+  });
+  it('starts a new chat from the skills hub', function () {
+    var handleStartNewChat = jest.fn();
+    renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread(_objectSpread({}, sidebarProps), {}, {
+      agentsNavActive: "mySkills",
+      handleStartNewChat: handleStartNewChat
+    })));
+    fireEvent.click(screen.getByLabelText('conversations.newChat'));
+    expect(handleStartNewChat).toHaveBeenCalled();
+  });
+  describe('skills feature access (MAIA_SKILLS_ACCESS)', function () {
+    var originalSkillsAccess = window.MAIA_SKILLS_ACCESS;
+    afterEach(function () {
+      window.MAIA_SKILLS_ACCESS = originalSkillsAccess;
+    });
+    it('shows the skills nav when the feature flag is enabled', function () {
+      window.MAIA_SKILLS_ACCESS = true;
+      renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread({}, sidebarProps)));
+      expect(screen.getByText('conversations.mySkillsNav')).toBeInTheDocument();
+    });
+    it('hides the skills nav when the feature flag is disabled', function () {
+      window.MAIA_SKILLS_ACCESS = false;
+      renderSidebar(/*#__PURE__*/_jsx(Sidebar, _objectSpread({}, sidebarProps)));
+      expect(screen.queryByText('conversations.mySkillsNav')).not.toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","GlobalContextTestProvider","Sidebar","jsx","_jsx","chatsState","loadingChats","chats","deleteChat","jest","fn","updateChat","fetchChats","limit","offset","hasMoreChats","loadMoreChats","isLoadingMoreChats","unreadCount","setUnreadCount","setChatReadState","mock","useChats","EVENTS","pmAiOpenConversation","pmAiNewConversation","pmAiMenuEdit","pmAiMenuDelete","aiSidebarNewChat","aiSidebarMyAgents","aiChatSidebar","useEvent","CORUserRole","CLEVEL","DIRECTOR","PROJECT_MANAGER","COLLABORATOR","FREELANCER","CLIENT","useUser","id","company_id","role_id","mapCORLang","lang","useIsSessionGenerating","useSessionMeta","useMaiaTaskPanelZIndex","FeedbackButton","children","EditQuestionModal","DeleteQuestionModal","fetchMaia","APPCUES_EVENTS","APPCUES_SELECTORS","trackAppcuesEvent","sidebarProps","onGoToChat","onError","handleGoToHome","handleOpenMarketplace","handleOpenSkills","showNewChat","refetchChats","handleSetRefetchChats","hasError","initialOpen","renderSidebar","ui","chat","title","sessionExternalId","date","Date","agent","agentId","emoji","isRead","describe","beforeEach","mockClear","it","_objectSpread","expect","getByText","toBeInTheDocument","queryByText","not","getByLabelText","toHaveTextContent","click","toHaveBeenCalledWith","objectContaining","handleStartNewChat","agentsNavActive","toHaveBeenCalled","originalSkillsAccess","window","MAIA_SKILLS_ACCESS","afterEach"],"sources":["../../../../src/components/molecules/Sidebar/Sidebar.spec.tsx"],"sourcesContent":["import { ReactElement } from 'react'\nimport { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider } from '../../../test/global-context'\nimport { Sidebar } from './Sidebar'\nimport type { ChatListItem } from '../../../store/chatsStore.types'\n\nconst chatsState = {\n  loadingChats: false,\n  chats: [] as ChatListItem[],\n  deleteChat: jest.fn(),\n  updateChat: jest.fn(),\n  fetchChats: jest.fn(),\n  limit: 20,\n  offset: 0,\n  hasMoreChats: false,\n  loadMoreChats: jest.fn(),\n  isLoadingMoreChats: false,\n  unreadCount: 0,\n  setUnreadCount: jest.fn(),\n  setChatReadState: jest.fn(),\n}\n\njest.mock('../../../hooks/useChats', () => ({\n  useChats: () => chatsState,\n}))\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: {\n    pmAiOpenConversation: 'PM_AI_OPEN_CONVERSATION',\n    pmAiNewConversation: 'PM_AI_NEW_CONVERSATION',\n    pmAiMenuEdit: 'PM_AI_MENU_EDIT',\n    pmAiMenuDelete: 'PM_AI_MENU_DELETE',\n    aiSidebarNewChat: 'AI_SIDEBAR_NEW_CHAT',\n    aiSidebarMyAgents: 'AI_SIDEBAR_MY_AGENTS',\n    aiChatSidebar: 'AI_CHAT_SIDEBAR',\n  },\n  useEvent: () => jest.fn(),\n}))\n\njest.mock('../../../context/cor-user', () => ({\n  CORUserRole: {\n    CLEVEL: 1,\n    DIRECTOR: 2,\n    PROJECT_MANAGER: 3,\n    COLLABORATOR: 4,\n    FREELANCER: 5,\n    CLIENT: 6,\n  },\n  useUser: () => ({ id: 99, company_id: 10, role_id: 3 }),\n}))\n\njest.mock('../../../lang/utils', () => ({\n  mapCORLang: (lang: string) => lang,\n}))\n\njest.mock('../../../store/sessions/useSessionMeta', () => ({\n  useIsSessionGenerating: () => false,\n  useSessionMeta: () => null,\n}))\n\njest.mock('../../../hooks/useMaiaTaskPanelZIndex', () => ({\n  useMaiaTaskPanelZIndex: () => 1500,\n}))\n\njest.mock('../../atoms/FeedbackButton', () => ({\n  FeedbackButton: () => <div>feedback</div>,\n}))\n\njest.mock('../../organisms/EditQuestionModal', () => ({\n  EditQuestionModal: () => null,\n}))\n\njest.mock('../../organisms/DeleteQuestionModal', () => ({\n  DeleteQuestionModal: () => null,\n}))\n\njest.mock('../../../services/maia/client', () => ({\n  fetchMaia: jest.fn(),\n}))\n\njest.mock('../../../services/appcues', () => ({\n  APPCUES_EVENTS: {},\n  APPCUES_SELECTORS: {},\n  trackAppcuesEvent: jest.fn(),\n}))\n\nconst sidebarProps = {\n  onGoToChat: jest.fn(),\n  onError: jest.fn(),\n  handleGoToHome: jest.fn(),\n  handleOpenMarketplace: jest.fn(),\n  handleOpenSkills: jest.fn(),\n  showNewChat: true,\n  refetchChats: false,\n  handleSetRefetchChats: jest.fn(),\n  hasError: false,\n  initialOpen: true,\n}\n\nconst renderSidebar = (ui: ReactElement) =>\n  renderWithProviders(<GlobalContextTestProvider>{ui}</GlobalContextTestProvider>)\n\nconst chat = (id: string, title: string): ChatListItem => ({\n  id,\n  sessionExternalId: id,\n  title,\n  date: new Date('2026-01-01'),\n  agent: 'MAIA',\n  agentId: 1,\n  emoji: '🤖',\n  isRead: true,\n})\n\ndescribe('Sidebar', () => {\n  beforeEach(() => {\n    chatsState.loadingChats = false\n    chatsState.chats = []\n    chatsState.unreadCount = 0\n    sidebarProps.onGoToChat.mockClear()\n    sidebarProps.hasError = false\n  })\n\n  it('shows the empty conversations state', () => {\n    renderSidebar(<Sidebar {...sidebarProps} />)\n\n    expect(screen.getByText('conversations.empty')).toBeInTheDocument()\n  })\n\n  it('shows the error state without chats', () => {\n    renderSidebar(<Sidebar {...sidebarProps} hasError />)\n\n    expect(screen.getByText('conversations.error')).toBeInTheDocument()\n    expect(screen.queryByText('conversations.empty')).not.toBeInTheDocument()\n  })\n\n  it('opens a conversation from the list', () => {\n    chatsState.chats = [chat('s1', 'Resumen del brief')]\n    chatsState.unreadCount = 4\n\n    renderSidebar(<Sidebar {...sidebarProps} />)\n\n    expect(screen.getByLabelText('conversations.unreadLabel')).toHaveTextContent('4')\n    fireEvent.click(screen.getByText('Resumen del brief'))\n\n    expect(sidebarProps.onGoToChat).toHaveBeenCalledWith(expect.objectContaining({ sessionExternalId: 's1' }))\n  })\n\n  it('starts a new chat from the skills hub', () => {\n    const handleStartNewChat = jest.fn()\n    renderSidebar(<Sidebar {...sidebarProps} agentsNavActive=\"mySkills\" handleStartNewChat={handleStartNewChat} />)\n\n    fireEvent.click(screen.getByLabelText('conversations.newChat'))\n    expect(handleStartNewChat).toHaveBeenCalled()\n  })\n\n  describe('skills feature access (MAIA_SKILLS_ACCESS)', () => {\n    const originalSkillsAccess = window.MAIA_SKILLS_ACCESS\n\n    afterEach(() => {\n      window.MAIA_SKILLS_ACCESS = originalSkillsAccess\n    })\n\n    it('shows the skills nav when the feature flag is enabled', () => {\n      window.MAIA_SKILLS_ACCESS = true\n      renderSidebar(<Sidebar {...sidebarProps} />)\n\n      expect(screen.getByText('conversations.mySkillsNav')).toBeInTheDocument()\n    })\n\n    it('hides the skills nav when the feature flag is disabled', () => {\n      window.MAIA_SKILLS_ACCESS = false\n      renderSidebar(<Sidebar {...sidebarProps} />)\n\n      expect(screen.queryByText('conversations.mySkillsNav')).not.toBeInTheDocument()\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}