@projectcor/maia-components 2.45.0 → 2.45.1-0

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

@@ -0,0 +1,444 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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()
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useSlashCommands', function () {
+  return {
+    useSlashCommands: function useSlashCommands() {
+      return {
+        commands: []
+      };
+    }
+  };
+});
+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,
+        close: jest.fn()
+      };
+    }
+  };
+});
+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() {
+      return null;
+    }
+  };
+});
+jest.mock('../ContextMentionEditor', function () {
+  var React = jest.requireActual('react');
+  return {
+    ContextMentionEditor: React.forwardRef(function (_ref, ref) {
+      var onInput = _ref.onInput,
+        _onKeyDown = _ref.onKeyDown,
+        placeholder = _ref.placeholder,
+        disabled = _ref.disabled;
+      var _React$useState = React.useState(''),
+        _React$useState2 = _slicedToArray(_React$useState, 2),
+        value = _React$useState2[0],
+        setValue = _React$useState2[1];
+      var emit = function emit(text) {
+        onInput === null || onInput === void 0 || onInput({
+          text: text,
+          mentions: [],
+          slashCommands: [],
+          trigger: {
+            active: false,
+            query: '',
+            atRunLength: 0
+          }
+        });
+      };
+      React.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);
+  });
+  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 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('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":["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","useSlashCommands","commands","useMentionPopover","popoverOpen","resetMentionOpenTracking","handleTrigger","handleKeyDown","popoverNode","close","useMaiaTaskPanelZIndex","ModalFileExceeds","SlashCommandDropdown","React","requireActual","ContextMentionEditor","forwardRef","_ref","ref","onInput","onKeyDown","placeholder","disabled","_React$useState","useState","_React$useState2","_slicedToArray","value","setValue","emit","text","mentions","slashCommands","trigger","active","query","atRunLength","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","children","onSendMessage","expect","getByPlaceholderText","toBeInTheDocument","toBeDisabled","change","getByLabelText","click","toHaveBeenCalledWith","toHaveValue","not","toHaveBeenCalled","onStopGeneration","isWriting","getByRole","getByText","mockClear","type","label","_renderWithProviders","isStreaming","container","querySelector","toBeTruthy","agent","orchestratorHomeComposer","queryByRole","keyDown","key","toggleWebSearch","isWebSearchActive","onFileAttach","fileInput","document","file","File","files","objectContaining","attachments","size"],"sources":["../../../../src/components/atoms/MAIAInput/MAIAInput.spec.tsx"],"sourcesContent":["import { 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\njest.mock('../../../hooks/useSlashCommands', () => ({\n  useSlashCommands: () => ({ commands: [] }),\n}))\n\njest.mock('../../../hooks/useMentionPopover', () => ({\n  useMentionPopover: () => ({\n    popoverOpen: false,\n    resetMentionOpenTracking: jest.fn(),\n    handleTrigger: jest.fn(),\n    handleKeyDown: () => false,\n    popoverNode: null,\n    close: jest.fn(),\n  }),\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: () => null,\n}))\n\njest.mock('../ContextMentionEditor', () => {\n  const React = jest.requireActual('react') as typeof import('react')\n  return {\n    ContextMentionEditor: React.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] = React.useState('')\n        const emit = (text: string) => {\n          onInput?.({\n            text,\n            mentions: [],\n            slashCommands: [],\n            trigger: { active: false, query: '', atRunLength: 0 },\n          })\n        }\n\n        React.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  })\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 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('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":[]}

package/lib/components/atoms/MAIAInput/MAIAInputEditor.helpers.js

@@ -0,0 +1,50 @@
+/** Líneas visuales con wrap de palabras al ancho dado (aprox. el navegador en LTR). */
+export var countVisualLinesWrapped = function countVisualLinesWrapped(raw, contentWidthPx, measureTextWidth) {
+  if (contentWidthPx <= 1) {
+    return 1;
+  }
+  var paragraphs = raw.split('\n');
+  var total = paragraphs.reduce(function (sum, paragraph) {
+    if (paragraph.length === 0) {
+      return sum + 1;
+    }
+    var words = paragraph.split(/\s+/).filter(function (word) {
+      return word.length > 0;
+    });
+    var _words$reduce = words.reduce(function (state, word, index) {
+        var wordWidth = measureTextWidth(word);
+        var spaceWidth = index > 0 ? measureTextWidth(' ') : 0;
+        if (wordWidth > contentWidthPx) {
+          var lines = state.linesInParagraph,
+            currentLineWidth = state.currentLineWidth;
+          if (currentLineWidth > 0) {
+            lines += 1;
+            currentLineWidth = 0;
+          }
+          lines += Math.ceil(wordWidth / contentWidthPx) - 1;
+          return {
+            linesInParagraph: lines,
+            currentLineWidth: 0
+          };
+        }
+        var candidateWidth = state.currentLineWidth === 0 ? wordWidth : state.currentLineWidth + spaceWidth + wordWidth;
+        if (candidateWidth > contentWidthPx && state.currentLineWidth > 0) {
+          return {
+            linesInParagraph: state.linesInParagraph + 1,
+            currentLineWidth: wordWidth
+          };
+        }
+        return {
+          linesInParagraph: state.linesInParagraph,
+          currentLineWidth: candidateWidth
+        };
+      }, {
+        linesInParagraph: 1,
+        currentLineWidth: 0
+      }),
+      linesInParagraph = _words$reduce.linesInParagraph;
+    return sum + linesInParagraph;
+  }, 0);
+  return Math.max(1, total);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,20 @@
+import { countVisualLinesWrapped } from './MAIAInputEditor.helpers';
+describe('MAIAInputEditor.helpers', function () {
+  var measure = function measure(text) {
+    return text.length * 10;
+  };
+  it('returns one line for empty width or single short line', function () {
+    expect(countVisualLinesWrapped('hola', 0, measure)).toBe(1);
+    expect(countVisualLinesWrapped('hola', 200, measure)).toBe(1);
+  });
+  it('wraps words when they exceed the available width', function () {
+    expect(countVisualLinesWrapped('hola mundo largo', 50, measure)).toBeGreaterThan(1);
+  });
+  it('counts explicit newlines as extra lines', function () {
+    expect(countVisualLinesWrapped('linea uno\nlinea dos', 200, measure)).toBe(2);
+  });
+  it('breaks oversized words across multiple lines', function () {
+    expect(countVisualLinesWrapped('supercalifragilistico', 30, measure)).toBeGreaterThan(1);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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