@projectcor/maia-components 2.50.0 → 2.50.1-0

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

@@ -0,0 +1,641 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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 React from 'react';
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { GlobalContextTestProvider } from '../../../test/global-context';
+import { MAIAInput } from './MAIAInput';
+import { jsx as _jsx } from "react/jsx-runtime";
+var insertSkillMention = jest.fn();
+var insertMentionTrigger = jest.fn();
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatPlusOpen: 'AI_CHAT_PLUS_OPEN',
+      aiChatQuickActionOpen: 'AI_CHAT_QUICK_ACTION_OPEN',
+      aiChatSkillOpen: 'AI_CHAT_SKILL_OPEN',
+      aiChatSkillSelect: 'AI_CHAT_SKILL_SELECT',
+      aiChatSkillRemove: 'AI_CHAT_SKILL_REMOVE'
+    },
+    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,
+        role_id: 3
+      };
+    }
+  };
+});
+var mockCanAccessToSkills = jest.fn(function () {
+  return true;
+});
+jest.mock('../../../constants/permissions', function () {
+  return {
+    canAccessToSkills: function canAccessToSkills() {
+      return mockCanAccessToSkills.apply(void 0, arguments);
+    },
+    isSkillsPilotCompany: function isSkillsPilotCompany() {
+      return true;
+    }
+  };
+});
+jest.mock('../../../hooks/useSkillsCatalog', function () {
+  return {
+    useSkillsCatalog: function useSkillsCatalog() {
+      return {
+        skills: [{
+          id: 'sk1',
+          name: 'Resumir',
+          description: 'Desc',
+          content: 'Resume'
+        }],
+        loading: false,
+        error: false,
+        fetchSkills: jest.fn()
+      };
+    }
+  };
+});
+var slashCommandsState = {
+  commands: [{
+    id: 'cmd-1',
+    title: 'Resumir brief',
+    description: 'Resume'
+  }]
+};
+jest.mock('../../../hooks/useSlashCommands', function () {
+  return {
+    useSlashCommands: function useSlashCommands() {
+      return slashCommandsState;
+    }
+  };
+});
+var mentionPopoverState = {
+  popoverOpen: false,
+  resetMentionOpenTracking: jest.fn(),
+  handleTrigger: jest.fn(),
+  handleKeyDown: jest.fn(function () {
+    return false;
+  }),
+  popoverNode: null,
+  close: jest.fn()
+};
+jest.mock('../../../hooks/useMentionPopover', function () {
+  return {
+    useMentionPopover: function useMentionPopover() {
+      return mentionPopoverState;
+    }
+  };
+});
+jest.mock('../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 1300;
+    }
+  };
+});
+jest.mock('../../organisms/ModalFileExceeds', function () {
+  return {
+    ModalFileExceeds: function ModalFileExceeds() {
+      return null;
+    }
+  };
+});
+jest.mock('../SlashCommandDropdown', function () {
+  return {
+    SlashCommandDropdown: function SlashCommandDropdown(_ref) {
+      var commands = _ref.commands,
+        onSelect = _ref.onSelect;
+      return /*#__PURE__*/_jsx("div", {
+        role: "listbox",
+        "aria-label": "slash-commands",
+        children: commands.map(function (command) {
+          return /*#__PURE__*/_jsx("button", {
+            type: "button",
+            onClick: function onClick() {
+              return onSelect(command);
+            },
+            children: command.title
+          }, command.id);
+        })
+      });
+    }
+  };
+});
+jest.mock('../ContextMentionEditor', function () {
+  var ReactActual = jest.requireActual('react');
+  return {
+    ContextMentionEditor: ReactActual.forwardRef(function (_ref2, ref) {
+      var onInput = _ref2.onInput,
+        _onKeyDown = _ref2.onKeyDown,
+        placeholder = _ref2.placeholder,
+        disabled = _ref2.disabled;
+      var _ReactActual$useState = ReactActual.useState(''),
+        _ReactActual$useState2 = _slicedToArray(_ReactActual$useState, 2),
+        value = _ReactActual$useState2[0],
+        setValue = _ReactActual$useState2[1];
+      var emit = function emit(text) {
+        onInput === null || onInput === void 0 || onInput(_objectSpread({
+          text: text,
+          mentions: [],
+          slashCommands: [],
+          trigger: {
+            active: false,
+            query: '',
+            atRunLength: 0
+          }
+        }, text.startsWith('/') ? {
+          slashTrigger: {
+            active: true,
+            query: text.slice(1)
+          }
+        } : {}));
+      };
+      ReactActual.useImperativeHandle(ref, function () {
+        return {
+          focus: jest.fn(),
+          clear: function clear() {
+            setValue('');
+            emit('');
+          },
+          setPlainText: function setPlainText(text) {
+            setValue(text);
+            emit(text);
+          },
+          serialize: function serialize() {
+            return {
+              text: value,
+              mentions: [],
+              slashCommands: []
+            };
+          },
+          insertMentionTrigger: insertMentionTrigger,
+          insertSlashTrigger: jest.fn(),
+          insertMention: jest.fn(),
+          insertSlashCommand: jest.fn(),
+          insertSkillTrigger: function insertSkillTrigger() {
+            onInput === null || onInput === void 0 || onInput({
+              text: '#',
+              mentions: [],
+              slashCommands: [],
+              trigger: {
+                active: false,
+                query: '',
+                atRunLength: 0
+              },
+              hashTrigger: {
+                active: true,
+                query: ''
+              }
+            });
+          },
+          insertSkillMention: insertSkillMention,
+          syncTriggerAtRunLength: jest.fn(),
+          syncSkillTrigger: jest.fn(),
+          hasVisualMultiline: function hasVisualMultiline() {
+            return false;
+          },
+          getEditorClientRect: function getEditorClientRect() {
+            return null;
+          }
+        };
+      });
+      return /*#__PURE__*/_jsx("textarea", {
+        "aria-label": "maia-editor",
+        placeholder: placeholder,
+        disabled: disabled,
+        value: value,
+        onChange: function onChange(event) {
+          setValue(event.target.value);
+          emit(event.target.value);
+        },
+        onKeyDown: function onKeyDown(event) {
+          return _onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(event);
+        }
+      });
+    })
+  };
+});
+var sendButton = function sendButton() {
+  return screen.getAllByRole('button').find(function (button) {
+    return !button.getAttribute('aria-label') && !button.getAttribute('aria-haspopup');
+  });
+};
+describe('MAIAInput', function () {
+  beforeEach(function () {
+    mockCanAccessToSkills.mockReturnValue(true);
+    mentionPopoverState.popoverOpen = false;
+    mentionPopoverState.popoverNode = null;
+    mentionPopoverState.handleKeyDown.mockReturnValue(false);
+  });
+  it('keeps send disabled without text', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        placeholder: "Escrib\xED"
+      })
+    }));
+    expect(screen.getByPlaceholderText('Escribí')).toBeInTheDocument();
+    expect(sendButton()).toBeDisabled();
+  });
+  it('sends the typed message and clears the editor', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: onSendMessage
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: 'Hola draft'
+      }
+    });
+    fireEvent.click(sendButton());
+    expect(onSendMessage).toHaveBeenCalledWith('Hola draft', [], []);
+    expect(screen.getByLabelText('maia-editor')).toHaveValue('');
+  });
+  it('does not send when disabled', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: onSendMessage,
+        disabled: true
+      })
+    }));
+    expect(screen.getByLabelText('maia-editor')).toBeDisabled();
+    expect(sendButton()).toBeDisabled();
+    fireEvent.click(sendButton());
+    expect(onSendMessage).not.toHaveBeenCalled();
+  });
+  it('shows stop while writing', function () {
+    var onStopGeneration = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        isWriting: true,
+        onStopGeneration: onStopGeneration
+      })
+    }));
+    fireEvent.click(sendButton());
+    expect(onStopGeneration).toHaveBeenCalled();
+  });
+  it('opens the plus menu', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.openPlusMenuAria'
+    }));
+    expect(screen.getByText('chat.plusMenuAttach')).toBeInTheDocument();
+    expect(screen.getByText('chat.searchWeb')).toBeInTheDocument();
+  });
+  it('opens the skills catalog and selects a skill', function () {
+    insertSkillMention.mockClear();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'mySkills.dropdownButton'
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: /#Resumir/
+    }));
+    expect(insertSkillMention).toHaveBeenCalledWith({
+      id: 'sk1',
+      type: 'skill',
+      label: '#Resumir'
+    });
+  });
+  it('keeps send disabled for whitespace-only text', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: '   '
+      }
+    });
+    expect(sendButton()).toBeDisabled();
+  });
+  it('marks the editor as streaming for assistive styling', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+        children: /*#__PURE__*/_jsx(MAIAInput, {
+          onSendMessage: jest.fn(),
+          isStreaming: true
+        })
+      })),
+      container = _renderWithProviders.container;
+    expect(container.querySelector('[data-maia-streaming="true"]')).toBeTruthy();
+  });
+  it('shows the mention button on orchestrator home before the agent is loaded', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        agent: null
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        orchestratorHomeComposer: true
+      })
+    }));
+    expect(screen.getByRole('button', {
+      name: 'chat.openMentionAria'
+    })).toBeInTheDocument();
+  });
+  it('hides the skills button when MAIA_SKILLS_ACCESS is not granted', function () {
+    mockCanAccessToSkills.mockReturnValue(false);
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    expect(screen.queryByRole('button', {
+      name: 'mySkills.dropdownButton'
+    })).not.toBeInTheDocument();
+  });
+  it('sends on Enter without shift', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: onSendMessage
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: 'Enviar con Enter'
+      }
+    });
+    fireEvent.keyDown(screen.getByLabelText('maia-editor'), {
+      key: 'Enter'
+    });
+    expect(onSendMessage).toHaveBeenCalledWith('Enviar con Enter', [], []);
+  });
+  it('toggles deep search from the plus menu', function () {
+    var toggleDeepSearch = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        toggleDeepSearch: toggleDeepSearch
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.openPlusMenuAria'
+    }));
+    fireEvent.click(screen.getByText('chat.plusMenuDeepInvestigation'));
+    expect(toggleDeepSearch).toHaveBeenCalled();
+  });
+  it('shows the active deep search chip when enabled', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        isDeepSearchActive: true
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    expect(screen.getByText('chat.plusMenuDeepInvestigation')).toBeInTheDocument();
+  });
+  it('toggles web search from the plus menu', function () {
+    var toggleWebSearch = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        toggleWebSearch: toggleWebSearch
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.openPlusMenuAria'
+    }));
+    fireEvent.click(screen.getByText('chat.searchWeb'));
+    expect(toggleWebSearch).toHaveBeenCalled();
+  });
+  it('shows the active web search chip when enabled', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        isWebSearchActive: true
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    expect(screen.getByText('chat.searchWeb')).toBeInTheDocument();
+  });
+  it('opens the mention trigger from the toolbar button', function () {
+    insertMentionTrigger.mockClear();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.openMentionAria'
+    }));
+    expect(insertMentionTrigger).toHaveBeenCalled();
+  });
+  it('forwards supported files through onFileAttach', function () {
+    var onFileAttach = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        onFileAttach: onFileAttach
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.openPlusMenuAria'
+    }));
+    fireEvent.click(screen.getByText('chat.plusMenuAttach'));
+    var fileInput = document.querySelector('input[type="file"]');
+    var file = new File(['content'], 'brief.pdf', {
+      type: 'application/pdf'
+    });
+    fireEvent.change(fileInput, {
+      target: {
+        files: [file]
+      }
+    });
+    expect(onFileAttach).toHaveBeenCalledWith(expect.objectContaining({
+      name: 'brief.pdf'
+    }));
+  });
+  it('renders the mention popover when it is open', function () {
+    mentionPopoverState.popoverOpen = true;
+    mentionPopoverState.popoverNode = /*#__PURE__*/_jsx("div", {
+      role: "listbox",
+      children: "mention-popover"
+    });
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    expect(screen.getByRole('listbox')).toHaveTextContent('mention-popover');
+  });
+  it('delegates keydown to the mention popover before sending', function () {
+    var onSendMessage = jest.fn();
+    mentionPopoverState.handleKeyDown.mockReturnValue(true);
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: onSendMessage
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: 'Hola'
+      }
+    });
+    fireEvent.keyDown(screen.getByLabelText('maia-editor'), {
+      key: 'Enter'
+    });
+    expect(mentionPopoverState.handleKeyDown).toHaveBeenCalled();
+    expect(onSendMessage).not.toHaveBeenCalled();
+  });
+  it('opens the slash command menu when typing a slash command', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        agent: {
+          id: '1',
+          name: 'MAIA',
+          type: 'orchestrator',
+          entity: 'global'
+        }
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: '/res'
+      }
+    });
+    expect(screen.getByRole('listbox', {
+      name: 'slash-commands'
+    })).toBeInTheDocument();
+    expect(screen.getByRole('button', {
+      name: 'Resumir brief'
+    })).toBeInTheDocument();
+  });
+  it('sends a slash command immediately when the editor is empty', function () {
+    var onSendMessage = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        agent: {
+          id: '1',
+          name: 'MAIA',
+          type: 'orchestrator',
+          entity: 'global'
+        }
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: onSendMessage
+      })
+    }));
+    fireEvent.change(screen.getByLabelText('maia-editor'), {
+      target: {
+        value: '/res'
+      }
+    });
+    fireEvent.click(screen.getByRole('button', {
+      name: 'Resumir brief'
+    }));
+    expect(onSendMessage).toHaveBeenCalledWith('Resumir brief', [], undefined, undefined, undefined, undefined, 'cmd-1');
+  });
+  it('shows the auto approve chip when enabled in context', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        isAutoApproveActive: true
+      },
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    expect(screen.getByText('chat.autoApproveChip')).toBeInTheDocument();
+  });
+  it('shows the file drop overlay while dragging files', function () {
+    var _screen$getByLabelTex;
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn()
+      })
+    }));
+    var wrapper = screen.getByLabelText('maia-editor').closest('[data-maia-input-root]');
+    var dragTarget = wrapper !== null && wrapper !== void 0 ? wrapper : (_screen$getByLabelTex = screen.getByLabelText('maia-editor').parentElement) === null || _screen$getByLabelTex === void 0 ? void 0 : _screen$getByLabelTex.parentElement;
+    if (!dragTarget) {
+      throw new Error('drag target not found');
+    }
+    fireEvent.dragEnter(dragTarget, {
+      dataTransfer: {
+        types: ['Files'],
+        items: [{
+          kind: 'file'
+        }]
+      }
+    });
+    expect(screen.getByText('chat.dropFilesHere')).toBeInTheDocument();
+  });
+  it('removes an attachment chip through onDeleteAttachment', function () {
+    var onDeleteAttachment = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        onDeleteAttachment: onDeleteAttachment,
+        attachments: [{
+          id: 'f1',
+          name: 'brief.pdf',
+          type: 'pdf',
+          size: 120,
+          file: new File([], 'brief.pdf', {
+            type: 'application/pdf'
+          })
+        }]
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'chat.removeAttachmentAria'
+    }));
+    expect(onDeleteAttachment).toHaveBeenCalledWith('f1');
+  });
+  it('enables send when attachments are provided by the parent', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(MAIAInput, {
+        onSendMessage: jest.fn(),
+        attachments: [{
+          id: 'f1',
+          name: 'brief.pdf',
+          type: 'pdf',
+          size: 120,
+          file: new File([], 'brief.pdf', {
+            type: 'application/pdf'
+          })
+        }]
+      })
+    }));
+    expect(screen.getByText('brief.pdf')).toBeInTheDocument();
+    expect(sendButton()).not.toBeDisabled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","fireEvent","renderWithProviders","screen","GlobalContextTestProvider","MAIAInput","jsx","_jsx","insertSkillMention","jest","fn","insertMentionTrigger","mock","EVENTS","aiChatPlusOpen","aiChatQuickActionOpen","aiChatSkillOpen","aiChatSkillSelect","aiChatSkillRemove","useEvent","CORUserRole","CLEVEL","DIRECTOR","PROJECT_MANAGER","COLLABORATOR","FREELANCER","CLIENT","useUser","id","role_id","mockCanAccessToSkills","canAccessToSkills","apply","arguments","isSkillsPilotCompany","useSkillsCatalog","skills","name","description","content","loading","error","fetchSkills","slashCommandsState","commands","title","useSlashCommands","mentionPopoverState","popoverOpen","resetMentionOpenTracking","handleTrigger","handleKeyDown","popoverNode","close","useMentionPopover","useMaiaTaskPanelZIndex","ModalFileExceeds","SlashCommandDropdown","_ref","onSelect","role","children","map","command","type","onClick","ReactActual","requireActual","ContextMentionEditor","forwardRef","_ref2","ref","onInput","onKeyDown","placeholder","disabled","_ReactActual$useState","useState","_ReactActual$useState2","_slicedToArray","value","setValue","emit","text","_objectSpread","mentions","slashCommands","trigger","active","query","atRunLength","startsWith","slashTrigger","slice","useImperativeHandle","focus","clear","setPlainText","serialize","insertSlashTrigger","insertMention","insertSlashCommand","insertSkillTrigger","hashTrigger","syncTriggerAtRunLength","syncSkillTrigger","hasVisualMultiline","getEditorClientRect","onChange","event","target","sendButton","getAllByRole","find","button","getAttribute","describe","beforeEach","mockReturnValue","it","onSendMessage","expect","getByPlaceholderText","toBeInTheDocument","toBeDisabled","change","getByLabelText","click","toHaveBeenCalledWith","toHaveValue","not","toHaveBeenCalled","onStopGeneration","isWriting","getByRole","getByText","mockClear","label","_renderWithProviders","isStreaming","container","querySelector","toBeTruthy","agent","orchestratorHomeComposer","queryByRole","keyDown","key","toggleDeepSearch","isDeepSearchActive","toggleWebSearch","isWebSearchActive","onFileAttach","fileInput","document","file","File","files","objectContaining","toHaveTextContent","entity","undefined","isAutoApproveActive","_screen$getByLabelTex","wrapper","closest","dragTarget","parentElement","Error","dragEnter","dataTransfer","types","items","kind","onDeleteAttachment","attachments","size"],"sources":["../../../../src/components/atoms/MAIAInput/MAIAInput.spec.tsx"],"sourcesContent":["import React from 'react'\nimport { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider } from '../../../test/global-context'\nimport { MAIAInput } from './MAIAInput'\n\nconst insertSkillMention = jest.fn()\nconst insertMentionTrigger = jest.fn()\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: {\n    aiChatPlusOpen: 'AI_CHAT_PLUS_OPEN',\n    aiChatQuickActionOpen: 'AI_CHAT_QUICK_ACTION_OPEN',\n    aiChatSkillOpen: 'AI_CHAT_SKILL_OPEN',\n    aiChatSkillSelect: 'AI_CHAT_SKILL_SELECT',\n    aiChatSkillRemove: 'AI_CHAT_SKILL_REMOVE',\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, role_id: 3 }),\n}))\n\nconst mockCanAccessToSkills = jest.fn(() => true)\n\njest.mock('../../../constants/permissions', () => ({\n  canAccessToSkills: (...args: unknown[]) => mockCanAccessToSkills(...args),\n  isSkillsPilotCompany: () => true,\n}))\n\njest.mock('../../../hooks/useSkillsCatalog', () => ({\n  useSkillsCatalog: () => ({\n    skills: [{ id: 'sk1', name: 'Resumir', description: 'Desc', content: 'Resume' }],\n    loading: false,\n    error: false,\n    fetchSkills: jest.fn(),\n  }),\n}))\n\nconst slashCommandsState = {\n  commands: [{ id: 'cmd-1', title: 'Resumir brief', description: 'Resume' }],\n}\n\njest.mock('../../../hooks/useSlashCommands', () => ({\n  useSlashCommands: () => slashCommandsState,\n}))\n\nconst mentionPopoverState = {\n  popoverOpen: false,\n  resetMentionOpenTracking: jest.fn(),\n  handleTrigger: jest.fn(),\n  handleKeyDown: jest.fn(() => false),\n  popoverNode: null as React.ReactNode,\n  close: jest.fn(),\n}\n\njest.mock('../../../hooks/useMentionPopover', () => ({\n  useMentionPopover: () => mentionPopoverState,\n}))\n\njest.mock('../../../hooks/useMaiaTaskPanelZIndex', () => ({\n  useMaiaTaskPanelZIndex: () => 1300,\n}))\n\njest.mock('../../organisms/ModalFileExceeds', () => ({\n  ModalFileExceeds: () => null,\n}))\n\njest.mock('../SlashCommandDropdown', () => ({\n  SlashCommandDropdown: ({\n    commands,\n    onSelect,\n  }: {\n    commands: Array<{ id: string; title: string }>\n    onSelect: (command: { id: string; title: string }) => void\n  }) => (\n    <div role=\"listbox\" aria-label=\"slash-commands\">\n      {commands.map(command => (\n        <button key={command.id} type=\"button\" onClick={() => onSelect(command)}>\n          {command.title}\n        </button>\n      ))}\n    </div>\n  ),\n}))\n\njest.mock('../ContextMentionEditor', () => {\n  const ReactActual = jest.requireActual('react') as typeof import('react')\n  return {\n    ContextMentionEditor: ReactActual.forwardRef(\n      (\n        {\n          onInput,\n          onKeyDown,\n          placeholder,\n          disabled,\n        }: {\n          onInput?: (state: {\n            text: string\n            mentions: unknown[]\n            slashCommands: unknown[]\n            trigger: { active: boolean; query: string; atRunLength: number }\n          }) => void\n          onKeyDown?: (event: KeyboardEvent) => void\n          placeholder?: string\n          disabled?: boolean\n        },\n        ref: {\n          focus: () => void\n          clear: () => void\n          setPlainText: (text: string) => void\n          serialize: () => { text: string; mentions: unknown[]; slashCommands: unknown[] }\n          insertMentionTrigger: () => void\n        } | null\n      ) => {\n        const [value, setValue] = ReactActual.useState('')\n        const emit = (text: string) => {\n          onInput?.({\n            text,\n            mentions: [],\n            slashCommands: [],\n            trigger: { active: false, query: '', atRunLength: 0 },\n            ...(text.startsWith('/') ? { slashTrigger: { active: true, query: text.slice(1) } } : {}),\n          } as never)\n        }\n\n        ReactActual.useImperativeHandle(ref, () => ({\n          focus: jest.fn(),\n          clear: () => {\n            setValue('')\n            emit('')\n          },\n          setPlainText: (text: string) => {\n            setValue(text)\n            emit(text)\n          },\n          serialize: () => ({ text: value, mentions: [], slashCommands: [] }),\n          insertMentionTrigger,\n          insertSlashTrigger: jest.fn(),\n          insertMention: jest.fn(),\n          insertSlashCommand: jest.fn(),\n          insertSkillTrigger: () => {\n            onInput?.({\n              text: '#',\n              mentions: [],\n              slashCommands: [],\n              trigger: { active: false, query: '', atRunLength: 0 },\n              hashTrigger: { active: true, query: '' },\n            } as never)\n          },\n          insertSkillMention,\n          syncTriggerAtRunLength: jest.fn(),\n          syncSkillTrigger: jest.fn(),\n          hasVisualMultiline: () => false,\n          getEditorClientRect: () => null,\n        }))\n\n        return (\n          <textarea\n            aria-label=\"maia-editor\"\n            placeholder={placeholder}\n            disabled={disabled}\n            value={value}\n            onChange={event => {\n              setValue(event.target.value)\n              emit(event.target.value)\n            }}\n            onKeyDown={event => onKeyDown?.(event as unknown as KeyboardEvent)}\n          />\n        )\n      }\n    ),\n  }\n})\n\nconst sendButton = () =>\n  screen\n    .getAllByRole('button')\n    .find(button => !button.getAttribute('aria-label') && !button.getAttribute('aria-haspopup'))\n\ndescribe('MAIAInput', () => {\n  beforeEach(() => {\n    mockCanAccessToSkills.mockReturnValue(true)\n    mentionPopoverState.popoverOpen = false\n    mentionPopoverState.popoverNode = null\n    mentionPopoverState.handleKeyDown.mockReturnValue(false)\n  })\n\n  it('keeps send disabled without text', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} placeholder=\"Escribí\" />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByPlaceholderText('Escribí')).toBeInTheDocument()\n    expect(sendButton()).toBeDisabled()\n  })\n\n  it('sends the typed message and clears the editor', () => {\n    const onSendMessage = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={onSendMessage} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: 'Hola draft' } })\n    fireEvent.click(sendButton() as HTMLButtonElement)\n\n    expect(onSendMessage).toHaveBeenCalledWith('Hola draft', [], [])\n    expect(screen.getByLabelText('maia-editor')).toHaveValue('')\n  })\n\n  it('does not send when disabled', () => {\n    const onSendMessage = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={onSendMessage} disabled />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByLabelText('maia-editor')).toBeDisabled()\n    expect(sendButton()).toBeDisabled()\n    fireEvent.click(sendButton() as HTMLButtonElement)\n    expect(onSendMessage).not.toHaveBeenCalled()\n  })\n\n  it('shows stop while writing', () => {\n    const onStopGeneration = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} isWriting onStopGeneration={onStopGeneration} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(sendButton() as HTMLButtonElement)\n    expect(onStopGeneration).toHaveBeenCalled()\n  })\n\n  it('opens the plus menu', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.openPlusMenuAria' }))\n\n    expect(screen.getByText('chat.plusMenuAttach')).toBeInTheDocument()\n    expect(screen.getByText('chat.searchWeb')).toBeInTheDocument()\n  })\n\n  it('opens the skills catalog and selects a skill', () => {\n    insertSkillMention.mockClear()\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.dropdownButton' }))\n\n    fireEvent.click(screen.getByRole('button', { name: /#Resumir/ }))\n    expect(insertSkillMention).toHaveBeenCalledWith({ id: 'sk1', type: 'skill', label: '#Resumir' })\n  })\n\n  it('keeps send disabled for whitespace-only text', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: '   ' } })\n    expect(sendButton()).toBeDisabled()\n  })\n\n  it('marks the editor as streaming for assistive styling', () => {\n    const { container } = renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} isStreaming />\n      </GlobalContextTestProvider>\n    )\n\n    expect(container.querySelector('[data-maia-streaming=\"true\"]')).toBeTruthy()\n  })\n\n  it('shows the mention button on orchestrator home before the agent is loaded', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ agent: null }}>\n        <MAIAInput onSendMessage={jest.fn()} orchestratorHomeComposer />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByRole('button', { name: 'chat.openMentionAria' })).toBeInTheDocument()\n  })\n\n  it('hides the skills button when MAIA_SKILLS_ACCESS is not granted', () => {\n    mockCanAccessToSkills.mockReturnValue(false)\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.queryByRole('button', { name: 'mySkills.dropdownButton' })).not.toBeInTheDocument()\n  })\n\n  it('sends on Enter without shift', () => {\n    const onSendMessage = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={onSendMessage} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: 'Enviar con Enter' } })\n    fireEvent.keyDown(screen.getByLabelText('maia-editor'), { key: 'Enter' })\n\n    expect(onSendMessage).toHaveBeenCalledWith('Enviar con Enter', [], [])\n  })\n\n  it('toggles deep search from the plus menu', () => {\n    const toggleDeepSearch = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ toggleDeepSearch }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.openPlusMenuAria' }))\n    fireEvent.click(screen.getByText('chat.plusMenuDeepInvestigation'))\n\n    expect(toggleDeepSearch).toHaveBeenCalled()\n  })\n\n  it('shows the active deep search chip when enabled', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ isDeepSearchActive: true }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('chat.plusMenuDeepInvestigation')).toBeInTheDocument()\n  })\n\n  it('toggles web search from the plus menu', () => {\n    const toggleWebSearch = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ toggleWebSearch }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.openPlusMenuAria' }))\n    fireEvent.click(screen.getByText('chat.searchWeb'))\n\n    expect(toggleWebSearch).toHaveBeenCalled()\n  })\n\n  it('shows the active web search chip when enabled', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ isWebSearchActive: true }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('chat.searchWeb')).toBeInTheDocument()\n  })\n\n  it('opens the mention trigger from the toolbar button', () => {\n    insertMentionTrigger.mockClear()\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.openMentionAria' }))\n    expect(insertMentionTrigger).toHaveBeenCalled()\n  })\n\n  it('forwards supported files through onFileAttach', () => {\n    const onFileAttach = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} onFileAttach={onFileAttach} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.openPlusMenuAria' }))\n    fireEvent.click(screen.getByText('chat.plusMenuAttach'))\n\n    const fileInput = document.querySelector('input[type=\"file\"]') as HTMLInputElement\n    const file = new File(['content'], 'brief.pdf', { type: 'application/pdf' })\n    fireEvent.change(fileInput, { target: { files: [file] } })\n\n    expect(onFileAttach).toHaveBeenCalledWith(expect.objectContaining({ name: 'brief.pdf' }))\n  })\n\n  it('renders the mention popover when it is open', () => {\n    mentionPopoverState.popoverOpen = true\n    mentionPopoverState.popoverNode = <div role=\"listbox\">mention-popover</div>\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByRole('listbox')).toHaveTextContent('mention-popover')\n  })\n\n  it('delegates keydown to the mention popover before sending', () => {\n    const onSendMessage = jest.fn()\n    mentionPopoverState.handleKeyDown.mockReturnValue(true)\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={onSendMessage} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: 'Hola' } })\n    fireEvent.keyDown(screen.getByLabelText('maia-editor'), { key: 'Enter' })\n\n    expect(mentionPopoverState.handleKeyDown).toHaveBeenCalled()\n    expect(onSendMessage).not.toHaveBeenCalled()\n  })\n\n  it('opens the slash command menu when typing a slash command', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ agent: { id: '1', name: 'MAIA', type: 'orchestrator', entity: 'global' } }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: '/res' } })\n\n    expect(screen.getByRole('listbox', { name: 'slash-commands' })).toBeInTheDocument()\n    expect(screen.getByRole('button', { name: 'Resumir brief' })).toBeInTheDocument()\n  })\n\n  it('sends a slash command immediately when the editor is empty', () => {\n    const onSendMessage = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ agent: { id: '1', name: 'MAIA', type: 'orchestrator', entity: 'global' } }}>\n        <MAIAInput onSendMessage={onSendMessage} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.change(screen.getByLabelText('maia-editor'), { target: { value: '/res' } })\n    fireEvent.click(screen.getByRole('button', { name: 'Resumir brief' }))\n\n    expect(onSendMessage).toHaveBeenCalledWith('Resumir brief', [], undefined, undefined, undefined, undefined, 'cmd-1')\n  })\n\n  it('shows the auto approve chip when enabled in context', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ isAutoApproveActive: true }}>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('chat.autoApproveChip')).toBeInTheDocument()\n  })\n\n  it('shows the file drop overlay while dragging files', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput onSendMessage={jest.fn()} />\n      </GlobalContextTestProvider>\n    )\n\n    const wrapper = screen.getByLabelText('maia-editor').closest('[data-maia-input-root]') as HTMLElement\n    const dragTarget = wrapper ?? screen.getByLabelText('maia-editor').parentElement?.parentElement\n    if (!dragTarget) {\n      throw new Error('drag target not found')\n    }\n\n    fireEvent.dragEnter(dragTarget, {\n      dataTransfer: { types: ['Files'], items: [{ kind: 'file' }] },\n    })\n\n    expect(screen.getByText('chat.dropFilesHere')).toBeInTheDocument()\n  })\n\n  it('removes an attachment chip through onDeleteAttachment', () => {\n    const onDeleteAttachment = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput\n          onSendMessage={jest.fn()}\n          onDeleteAttachment={onDeleteAttachment}\n          attachments={[\n            {\n              id: 'f1',\n              name: 'brief.pdf',\n              type: 'pdf',\n              size: 120,\n              file: new File([], 'brief.pdf', { type: 'application/pdf' }),\n            },\n          ]}\n        />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'chat.removeAttachmentAria' }))\n\n    expect(onDeleteAttachment).toHaveBeenCalledWith('f1')\n  })\n\n  it('enables send when attachments are provided by the parent', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <MAIAInput\n          onSendMessage={jest.fn()}\n          attachments={[\n            {\n              id: 'f1',\n              name: 'brief.pdf',\n              type: 'pdf',\n              size: 120,\n              file: new File([], 'brief.pdf', { type: 'application/pdf' }),\n            },\n          ]}\n        />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('brief.pdf')).toBeInTheDocument()\n    expect(sendButton()).not.toBeDisabled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}