@projectcor/maia-components 2.35.3-0 → 2.35.4-0

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

@@ -0,0 +1,283 @@
+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();
+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
+      };
+    }
+  };
+});
+jest.mock('../../../constants/permissions', function () {
+  return {
+    canAccessToSkills: function canAccessToSkills() {
+      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,
+        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: jest.fn(),
+          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);
+        }
+      });
+    })
+  };
+});
+var sendButton = function sendButton() {
+  return screen.getAllByRole('button').find(function (button) {
+    return !button.getAttribute('aria-label') && !button.getAttribute('aria-haspopup');
+  });
+};
+describe('MAIAInput', function () {
+  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'
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","GlobalContextTestProvider","MAIAInput","jsx","_jsx","insertSkillMention","jest","fn","mock","EVENTS","aiChatPlusOpen","aiChatQuickActionOpen","aiChatSkillOpen","aiChatSkillSelect","aiChatSkillRemove","useEvent","CORUserRole","CLEVEL","DIRECTOR","PROJECT_MANAGER","COLLABORATOR","FREELANCER","CLIENT","useUser","id","role_id","canAccessToSkills","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","placeholder","disabled","_React$useState","useState","_React$useState2","_slicedToArray","value","setValue","emit","text","mentions","slashCommands","trigger","active","query","atRunLength","useImperativeHandle","focus","clear","setPlainText","serialize","insertMentionTrigger","insertSlashTrigger","insertMention","insertSlashCommand","insertSkillTrigger","hashTrigger","syncTriggerAtRunLength","syncSkillTrigger","hasVisualMultiline","getEditorClientRect","onChange","event","target","sendButton","getAllByRole","find","button","getAttribute","describe","it","children","onSendMessage","expect","getByPlaceholderText","toBeInTheDocument","toBeDisabled","change","getByLabelText","click","toHaveBeenCalledWith","toHaveValue","not","toHaveBeenCalled","onStopGeneration","isWriting","getByRole","getByText","mockClear","type","label"],"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()\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\njest.mock('../../../constants/permissions', () => ({\n  canAccessToSkills: () => 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          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          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: jest.fn(),\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          />\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  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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,68 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ReasoningBlock } from './ReasoningBlock';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../MaiaStreamdown/MaiaStreamdown', function () {
+  return {
+    MaiaStreamdown: function MaiaStreamdown(_ref) {
+      var children = _ref.children;
+      return /*#__PURE__*/_jsx("div", {
+        children: children
+      });
+    }
+  };
+});
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatThinking: 'AI_CHAT_THINKING'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+describe('ReasoningBlock', function () {
+  it('returns null without visible steps', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(ReasoningBlock, {
+        messageId: "m1",
+        trace: {
+          steps: [{
+            i: 0,
+            type: 'thinking',
+            text: '...'
+          }],
+          summary: {
+            stepCount: 1,
+            toolCount: 0
+          }
+        }
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('toggles the expanded trace', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ReasoningBlock, {
+      messageId: "m1",
+      trace: {
+        steps: [{
+          i: 0,
+          type: 'narration',
+          text: 'Revisando'
+        }, {
+          i: 1,
+          type: 'tool',
+          tool: 'edit_task'
+        }],
+        summary: {
+          stepCount: 2,
+          toolCount: 1
+        }
+      }
+    }));
+    var toggle = screen.getByRole('button');
+    expect(toggle).toHaveAttribute('aria-expanded', 'false');
+    fireEvent.click(toggle);
+    expect(toggle).toHaveAttribute('aria-expanded', 'true');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,107 @@
+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 { SkillsDropdown } from './SkillsDropdown';
+import { jsx as _jsx } from "react/jsx-runtime";
+var skill = function skill(overrides) {
+  return _objectSpread({
+    id: 'sk1',
+    name: 'Resumir',
+    description: 'Resume briefs',
+    content: 'Resume el brief',
+    access_type: 'only_me'
+  }, overrides);
+};
+var skills = [skill({
+  id: 'sk1',
+  name: 'Resumir'
+}), skill({
+  id: 'sk2',
+  name: 'Traducir',
+  description: ''
+})];
+describe('SkillsDropdown', function () {
+  var onSelect = jest.fn();
+  var onCreate = jest.fn();
+  var onClose = jest.fn();
+  beforeEach(function () {
+    onSelect.mockClear();
+    onCreate.mockClear();
+    onClose.mockClear();
+  });
+  it('filters by name and selects a skill', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SkillsDropdown, {
+      skills: skills,
+      query: "trad",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    var items = screen.getAllByRole('button');
+    expect(items).toHaveLength(1);
+    expect(items[0]).toHaveTextContent('#Traducir');
+    expect(screen.queryByText('#Resumir')).not.toBeInTheDocument();
+    fireEvent.click(items[0]);
+    expect(onSelect).toHaveBeenCalledWith(skills[1]);
+  });
+  it('shows the empty state when nothing matches', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SkillsDropdown, {
+      skills: skills,
+      query: "zzz",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    expect(screen.getByText('mySkills.dropdownEmpty')).toBeInTheDocument();
+  });
+  it('shows the error state', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SkillsDropdown, {
+      skills: skills,
+      query: "",
+      error: true,
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    expect(screen.getByText('mySkills.dropdownError')).toBeInTheDocument();
+  });
+  it('creates a skill from the header action', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SkillsDropdown, {
+      skills: skills,
+      query: "",
+      canCreate: true,
+      onCreate: onCreate,
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'mySkills.dropdownCreate'
+    }));
+    expect(onCreate).toHaveBeenCalled();
+  });
+  it('selects the highlighted skill with Enter and closes on Escape', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SkillsDropdown, {
+      skills: skills,
+      query: "",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    fireEvent.keyDown(document, {
+      key: 'Enter'
+    });
+    expect(onSelect).toHaveBeenCalledWith(skills[0]);
+    fireEvent.keyDown(document, {
+      key: 'Escape'
+    });
+    expect(onClose).toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","SkillsDropdown","jsx","_jsx","skill","overrides","_objectSpread","id","name","description","content","access_type","skills","describe","onSelect","jest","fn","onCreate","onClose","beforeEach","mockClear","it","query","bottom","left","items","getAllByRole","expect","toHaveLength","toHaveTextContent","queryByText","not","toBeInTheDocument","click","toHaveBeenCalledWith","getByText","error","canCreate","getByRole","toHaveBeenCalled","keyDown","document","key"],"sources":["../../../../src/components/atoms/SkillsDropdown/SkillsDropdown.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport type { Skill } from '../../../types/skill'\nimport { SkillsDropdown } from './SkillsDropdown'\n\nconst skill = (overrides: Partial<Skill>): Skill => ({\n  id: 'sk1',\n  name: 'Resumir',\n  description: 'Resume briefs',\n  content: 'Resume el brief',\n  access_type: 'only_me',\n  ...overrides,\n})\n\nconst skills = [skill({ id: 'sk1', name: 'Resumir' }), skill({ id: 'sk2', name: 'Traducir', description: '' })]\n\ndescribe('SkillsDropdown', () => {\n  const onSelect = jest.fn()\n  const onCreate = jest.fn()\n  const onClose = jest.fn()\n\n  beforeEach(() => {\n    onSelect.mockClear()\n    onCreate.mockClear()\n    onClose.mockClear()\n  })\n\n  it('filters by name and selects a skill', () => {\n    renderWithProviders(\n      <SkillsDropdown skills={skills} query=\"trad\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    const items = screen.getAllByRole('button')\n    expect(items).toHaveLength(1)\n    expect(items[0]).toHaveTextContent('#Traducir')\n    expect(screen.queryByText('#Resumir')).not.toBeInTheDocument()\n\n    fireEvent.click(items[0])\n    expect(onSelect).toHaveBeenCalledWith(skills[1])\n  })\n\n  it('shows the empty state when nothing matches', () => {\n    renderWithProviders(\n      <SkillsDropdown skills={skills} query=\"zzz\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    expect(screen.getByText('mySkills.dropdownEmpty')).toBeInTheDocument()\n  })\n\n  it('shows the error state', () => {\n    renderWithProviders(\n      <SkillsDropdown skills={skills} query=\"\" error onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    expect(screen.getByText('mySkills.dropdownError')).toBeInTheDocument()\n  })\n\n  it('creates a skill from the header action', () => {\n    renderWithProviders(\n      <SkillsDropdown\n        skills={skills}\n        query=\"\"\n        canCreate\n        onCreate={onCreate}\n        onSelect={onSelect}\n        onClose={onClose}\n        bottom={0}\n        left={0}\n      />\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.dropdownCreate' }))\n    expect(onCreate).toHaveBeenCalled()\n  })\n\n  it('selects the highlighted skill with Enter and closes on Escape', () => {\n    renderWithProviders(\n      <SkillsDropdown skills={skills} query=\"\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    fireEvent.keyDown(document, { key: 'Enter' })\n    expect(onSelect).toHaveBeenCalledWith(skills[0])\n\n    fireEvent.keyDown(document, { key: 'Escape' })\n    expect(onClose).toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,85 @@
+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 { SlashCommandDropdown } from './SlashCommandDropdown';
+import { jsx as _jsx } from "react/jsx-runtime";
+var action = function action(overrides) {
+  return _objectSpread({
+    id: '1',
+    title: 'Crear tarea',
+    subtitle: 'Nueva tarea',
+    prompt: 'p',
+    language: null,
+    category: 'tasks'
+  }, overrides);
+};
+var commands = [action({
+  id: 'task',
+  title: 'Crear tarea',
+  category: 'tasks'
+}), action({
+  id: 'hours',
+  title: 'Cargar horas',
+  subtitle: 'Esta semana',
+  category: 'hours'
+})];
+describe('SlashCommandDropdown', function () {
+  var onSelect = jest.fn();
+  var onClose = jest.fn();
+  beforeEach(function () {
+    onSelect.mockClear();
+    onClose.mockClear();
+  });
+  it('filters commands by query and selects one', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "horas",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    var hoursButton = screen.getByRole('button', {
+      name: /Cargar horas/
+    });
+    expect(hoursButton).toBeInTheDocument();
+    expect(screen.queryByRole('button', {
+      name: /Crear tarea/
+    })).not.toBeInTheDocument();
+    fireEvent.click(hoursButton);
+    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({
+      id: 'hours'
+    }));
+  });
+  it('closes on Escape and outside click', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    fireEvent.keyDown(document, {
+      key: 'Escape'
+    });
+    expect(onClose).toHaveBeenCalled();
+    onClose.mockClear();
+    fireEvent.mouseDown(document.body);
+    expect(onClose).toHaveBeenCalled();
+  });
+  it('returns null when nothing matches', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+        commands: commands,
+        query: "zzz",
+        onSelect: onSelect,
+        onClose: onClose,
+        bottom: 0,
+        left: 0
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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