@projectcor/maia-components 2.44.4 → 2.44.5-0

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

@@ -0,0 +1,246 @@
+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 { renderWithProviders, screen } from '../../../test/test-utils';
+import { GlobalContextTestProvider, testAgent } from '../../../test/global-context';
+import { options } from '../ChatAIModal/constants';
+import { ChatAIHome } from './ChatAIHome';
+import { jsx as _jsx } from "react/jsx-runtime";
+var mockHandleGetFrequentlyAskedQuestions = jest.fn();
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatContextSelected: 'AI_CHAT_CONTEXT_SELECTED'
+    },
+    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,
+        firstName: 'Ana',
+        role_id: 3
+      };
+    },
+    isCollaboratorRole: function isCollaboratorRole() {
+      return false;
+    },
+    isManagerRole: function isManagerRole() {
+      return true;
+    }
+  };
+});
+jest.mock('../../../hooks/useRecentContexts', function () {
+  return {
+    useRecentContexts: function useRecentContexts() {
+      return {
+        contexts: [],
+        loading: false
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useFrequentlyUsedActions', function () {
+  return {
+    useFrequentlyUsedActions: function useFrequentlyUsedActions() {
+      return {
+        actions: [],
+        loading: false
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useFrequentlyAskedQuestions', function () {
+  return {
+    useFrequentlyAskedQuestions: jest.fn(function () {
+      return {
+        faqs: [{
+          id: 'faq-1',
+          title: 'FAQ de prueba',
+          category: 'general'
+        }],
+        loading: false,
+        handleGetFrequentlyAskedQuestions: mockHandleGetFrequentlyAskedQuestions
+      };
+    })
+  };
+});
+jest.mock('../../atoms/FrequentlyAskedQuestions', function () {
+  return {
+    FrequentlyAskedQuestions: function FrequentlyAskedQuestions() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "homeMenu.faq.startTitle"
+      });
+    }
+  };
+});
+jest.mock('../../atoms/FrequentlyUsedActions', function () {
+  return {
+    FrequentlyUsedActions: function FrequentlyUsedActions() {
+      return null;
+    }
+  };
+});
+jest.mock('./ChatAIHomeMaiaker', function () {
+  return {
+    ChatAIHomeMaiaker: function ChatAIHomeMaiaker() {
+      return null;
+    }
+  };
+});
+var orchestratorAgent = _objectSpread(_objectSpread({}, testAgent), {}, {
+  type: 'orchestrator'
+});
+var defaultHandlers = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, options.home, jest.fn()), options.chatsHistory, jest.fn()), options.projectSummary, jest.fn()), options.chat, jest.fn()), options.projectSelector, jest.fn()), options.clientSelector, jest.fn()), options.myAgents, jest.fn()), options.mySkills, jest.fn());
+var renderHome = function renderHome(ui, context) {
+  return renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+    value: context,
+    children: ui
+  }));
+};
+describe('ChatAIHome FAQs por contexto pineado', function () {
+  beforeEach(function () {
+    mockHandleGetFrequentlyAskedQuestions.mockClear();
+  });
+  it('muestra FAQs y dispara fetch con contexto cliente (sección client)', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'client',
+      agent: orchestratorAgent,
+      client: {
+        id: 5,
+        name: 'Cliente Beta'
+      }
+    });
+    expect(screen.getByText('homeMenu.faq.startTitle')).toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).toHaveBeenCalled();
+  });
+  it('no muestra FAQs ni fetch con contexto proyecto (sección project)', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'project',
+      agent: orchestratorAgent,
+      project: {
+        id: 10,
+        name: 'Proyecto Alpha'
+      },
+      chipsProject: {
+        projectId: '10',
+        projectName: 'Proyecto Alpha',
+        clientName: 'Cliente Beta'
+      }
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+  it('no muestra FAQs ni fetch con contexto proyecto desde header', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'header',
+      agent: orchestratorAgent,
+      chipsProject: {
+        projectId: '10',
+        projectName: 'Proyecto Alpha',
+        clientName: 'Cliente Beta'
+      }
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+  it('muestra FAQs con contexto cliente desde header', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'header',
+      agent: orchestratorAgent,
+      client: {
+        id: 5,
+        name: 'Cliente Beta'
+      }
+    });
+    expect(screen.getByText('homeMenu.faq.startTitle')).toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).toHaveBeenCalled();
+  });
+  it('no muestra FAQs en header sin contexto pineado (paso de recientes)', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'header',
+      agent: orchestratorAgent
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+  it('no muestra FAQs con contexto tarea (sección task)', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'task',
+      agent: orchestratorAgent,
+      task: {
+        id: '99',
+        name: 'Tarea X',
+        projectId: 10,
+        clientId: 5
+      },
+      chipsProject: {
+        projectId: '10',
+        projectName: 'Proyecto Alpha',
+        clientName: 'Cliente Beta'
+      }
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+  it('no muestra FAQs en planner', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'planner',
+      agent: orchestratorAgent
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+  it('no afecta agentes personalizados', function () {
+    renderHome(/*#__PURE__*/_jsx(ChatAIHome, {
+      onStartChat: jest.fn(),
+      handlers: defaultHandlers
+    }), {
+      section: 'client',
+      agent: _objectSpread(_objectSpread({}, testAgent), {}, {
+        type: 'custom',
+        introduction: 'Hola custom'
+      }),
+      client: {
+        id: 5,
+        name: 'Cliente Beta'
+      }
+    });
+    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument();
+    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["renderWithProviders","screen","GlobalContextTestProvider","testAgent","options","ChatAIHome","jsx","_jsx","mockHandleGetFrequentlyAskedQuestions","jest","fn","mock","EVENTS","aiChatContextSelected","useEvent","CORUserRole","CLEVEL","DIRECTOR","PROJECT_MANAGER","COLLABORATOR","FREELANCER","CLIENT","useUser","id","firstName","role_id","isCollaboratorRole","isManagerRole","useRecentContexts","contexts","loading","useFrequentlyUsedActions","actions","useFrequentlyAskedQuestions","faqs","title","category","handleGetFrequentlyAskedQuestions","FrequentlyAskedQuestions","children","FrequentlyUsedActions","ChatAIHomeMaiaker","orchestratorAgent","_objectSpread","type","defaultHandlers","_defineProperty","home","chatsHistory","projectSummary","chat","projectSelector","clientSelector","myAgents","mySkills","renderHome","ui","context","value","describe","beforeEach","mockClear","it","onStartChat","handlers","section","agent","client","name","expect","getByText","toBeInTheDocument","toHaveBeenCalled","project","chipsProject","projectId","projectName","clientName","queryByText","not","task","clientId","introduction"],"sources":["../../../../src/components/molecules/ChatAIHome/ChatAIHome.spec.tsx"],"sourcesContent":["import { ReactElement } from 'react'\nimport { renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider, testAgent } from '../../../test/global-context'\nimport { options } from '../ChatAIModal/constants'\nimport { ChatAIHome } from './ChatAIHome'\n\nconst mockHandleGetFrequentlyAskedQuestions = jest.fn()\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: {\n    aiChatContextSelected: 'AI_CHAT_CONTEXT_SELECTED',\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, firstName: 'Ana', role_id: 3 }),\n  isCollaboratorRole: () => false,\n  isManagerRole: () => true,\n}))\n\njest.mock('../../../hooks/useRecentContexts', () => ({\n  useRecentContexts: () => ({ contexts: [], loading: false }),\n}))\n\njest.mock('../../../hooks/useFrequentlyUsedActions', () => ({\n  useFrequentlyUsedActions: () => ({ actions: [], loading: false }),\n}))\n\njest.mock('../../../hooks/useFrequentlyAskedQuestions', () => ({\n  useFrequentlyAskedQuestions: jest.fn(() => ({\n    faqs: [{ id: 'faq-1', title: 'FAQ de prueba', category: 'general' }],\n    loading: false,\n    handleGetFrequentlyAskedQuestions: mockHandleGetFrequentlyAskedQuestions,\n  })),\n}))\n\njest.mock('../../atoms/FrequentlyAskedQuestions', () => ({\n  FrequentlyAskedQuestions: () => <div>homeMenu.faq.startTitle</div>,\n}))\n\njest.mock('../../atoms/FrequentlyUsedActions', () => ({\n  FrequentlyUsedActions: () => null,\n}))\n\njest.mock('./ChatAIHomeMaiaker', () => ({\n  ChatAIHomeMaiaker: () => null,\n}))\n\nconst orchestratorAgent = { ...testAgent, type: 'orchestrator' as const }\n\nconst defaultHandlers = {\n  [options.home]: jest.fn(),\n  [options.chatsHistory]: jest.fn(),\n  [options.projectSummary]: jest.fn(),\n  [options.chat]: jest.fn(),\n  [options.projectSelector]: jest.fn(),\n  [options.clientSelector]: jest.fn(),\n  [options.myAgents]: jest.fn(),\n  [options.mySkills]: jest.fn(),\n}\n\nconst renderHome = (ui: ReactElement, context?: Parameters<typeof GlobalContextTestProvider>[0]['value']) =>\n  renderWithProviders(<GlobalContextTestProvider value={context}>{ui}</GlobalContextTestProvider>)\n\ndescribe('ChatAIHome FAQs por contexto pineado', () => {\n  beforeEach(() => {\n    mockHandleGetFrequentlyAskedQuestions.mockClear()\n  })\n\n  it('muestra FAQs y dispara fetch con contexto cliente (sección client)', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'client',\n      agent: orchestratorAgent,\n      client: { id: 5, name: 'Cliente Beta' },\n    })\n\n    expect(screen.getByText('homeMenu.faq.startTitle')).toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).toHaveBeenCalled()\n  })\n\n  it('no muestra FAQs ni fetch con contexto proyecto (sección project)', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'project',\n      agent: orchestratorAgent,\n      project: { id: 10, name: 'Proyecto Alpha' },\n      chipsProject: {\n        projectId: '10',\n        projectName: 'Proyecto Alpha',\n        clientName: 'Cliente Beta',\n      },\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n\n  it('no muestra FAQs ni fetch con contexto proyecto desde header', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'header',\n      agent: orchestratorAgent,\n      chipsProject: {\n        projectId: '10',\n        projectName: 'Proyecto Alpha',\n        clientName: 'Cliente Beta',\n      },\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n\n  it('muestra FAQs con contexto cliente desde header', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'header',\n      agent: orchestratorAgent,\n      client: { id: 5, name: 'Cliente Beta' },\n    })\n\n    expect(screen.getByText('homeMenu.faq.startTitle')).toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).toHaveBeenCalled()\n  })\n\n  it('no muestra FAQs en header sin contexto pineado (paso de recientes)', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'header',\n      agent: orchestratorAgent,\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n\n  it('no muestra FAQs con contexto tarea (sección task)', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'task',\n      agent: orchestratorAgent,\n      task: { id: '99', name: 'Tarea X', projectId: 10, clientId: 5 },\n      chipsProject: {\n        projectId: '10',\n        projectName: 'Proyecto Alpha',\n        clientName: 'Cliente Beta',\n      },\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n\n  it('no muestra FAQs en planner', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'planner',\n      agent: orchestratorAgent,\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n\n  it('no afecta agentes personalizados', () => {\n    renderHome(<ChatAIHome onStartChat={jest.fn()} handlers={defaultHandlers} />, {\n      section: 'client',\n      agent: { ...testAgent, type: 'custom', introduction: 'Hola custom' },\n      client: { id: 5, name: 'Cliente Beta' },\n    })\n\n    expect(screen.queryByText('homeMenu.faq.startTitle')).not.toBeInTheDocument()\n    expect(mockHandleGetFrequentlyAskedQuestions).not.toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/ChatAIHome/ChatAIHomeMaiaker.spec.js

@@ -0,0 +1,86 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ChatAIHomeMaiaker } from './ChatAIHomeMaiaker';
+import { jsx as _jsx } from "react/jsx-runtime";
+var trackEvent = jest.fn();
+var handleGetAgentSuggestions = jest.fn();
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatMpSelectAgent: 'AI_CHAT_MP_SELECT_AGENT'
+    },
+    useEvent: function useEvent() {
+      return trackEvent;
+    }
+  };
+});
+jest.mock('../../../lang/utils', function () {
+  return {
+    mapCORLang: function mapCORLang() {
+      return 'es';
+    }
+  };
+});
+var mockUseAgentSuggestions = jest.fn();
+jest.mock('../../../hooks/useAgentSuggestions', function () {
+  return {
+    useAgentSuggestions: function useAgentSuggestions() {
+      return mockUseAgentSuggestions.apply(void 0, arguments);
+    }
+  };
+});
+var categorized = {
+  id: 'sug-1',
+  title: 'Brief creativo',
+  subtitle: 'Genera un brief',
+  language: 'es',
+  category: 'briefs',
+  order: 1,
+  emoji: null
+};
+var customAgent = {
+  id: 'sug-custom',
+  title: 'Mi agente',
+  subtitle: 'Personalizado',
+  language: 'es',
+  category: null,
+  order: 0,
+  emoji: '🎯'
+};
+describe('ChatAIHomeMaiaker', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    mockUseAgentSuggestions.mockReturnValue({
+      suggestions: [customAgent, categorized],
+      loading: false,
+      error: null,
+      handleGetAgentSuggestions: handleGetAgentSuggestions
+    });
+  });
+  it('loads suggestions for the mapped language on mount', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHomeMaiaker, {
+      onStartChat: jest.fn()
+    }));
+    expect(mockUseAgentSuggestions).toHaveBeenCalledWith('es');
+    expect(handleGetAgentSuggestions).toHaveBeenCalledTimes(1);
+  });
+  it('starts chat and tracks amplitude when a category card is clicked', function () {
+    var onStartChat = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHomeMaiaker, {
+      onStartChat: onStartChat
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: /Brief creativo/i
+    }));
+    expect(trackEvent).toHaveBeenCalledWith('AI_CHAT_MP_SELECT_AGENT', {
+      agent_title: 'Brief creativo'
+    });
+    expect(onStartChat).toHaveBeenCalledWith('Brief creativo', null, undefined, 'sug-1');
+  });
+  it('uses category emoji fallback when suggestion emoji is empty', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAIHomeMaiaker, {
+      onStartChat: jest.fn()
+    }));
+    expect(screen.getByText('📝')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/molecules/ChatAIMessages/ChatAICreateAgentActions.spec.js

@@ -0,0 +1,104 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { fetchAgentDetailAndParsedForAbm } from '../../../services/maia/Agents/fetchAgentDetail';
+import { ChatAICreateAgentActions } from './ChatAICreateAgentActions';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../services/maia/Agents/fetchAgentDetail', function () {
+  return {
+    fetchAgentDetailAndParsedForAbm: jest.fn()
+  };
+});
+jest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: jest.fn()
+      };
+    }
+  };
+});
+var fetchDetail = fetchAgentDetailAndParsedForAbm;
+var flags = window;
+describe('ChatAICreateAgentActions', function () {
+  beforeEach(function () {
+    flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true;
+    fetchDetail.mockResolvedValue({
+      chatAgent: {
+        id: 'a1',
+        name: 'Nuevo',
+        emoji: '✨',
+        type: 'custom'
+      },
+      abmParsed: {
+        id: 'a1',
+        name: 'Nuevo'
+      }
+    });
+  });
+  afterEach(function () {
+    delete flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS;
+  });
+  it('returns null without the multi-agents flag', function () {
+    delete flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS;
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(ChatAICreateAgentActions, {
+        agentId: "a1"
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('opens a new chat with the created agent', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var onOpen;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          onOpen = jest.fn();
+          document.addEventListener('maia-open-new-chat-with-agent', onOpen);
+          renderWithProviders(/*#__PURE__*/_jsx(ChatAICreateAgentActions, {
+            agentId: "a1"
+          }));
+          fireEvent.click(screen.getByRole('button', {
+            name: 'chat.createAgentActionStartChat'
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            expect(fetchDetail).toHaveBeenCalledWith('a1');
+            expect(onOpen).toHaveBeenCalled();
+          });
+        case 1:
+          document.removeEventListener('maia-open-new-chat-with-agent', onOpen);
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('opens the ABM on the knowledge section', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var onAbm, event;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onAbm = jest.fn();
+          document.addEventListener('abm-agent-modal-set-values', onAbm);
+          renderWithProviders(/*#__PURE__*/_jsx(ChatAICreateAgentActions, {
+            agentId: "a1"
+          }));
+          fireEvent.click(screen.getByRole('button', {
+            name: 'chat.createAgentActionKnowledge'
+          }));
+          _context2.next = 1;
+          return waitFor(function () {
+            expect(onAbm).toHaveBeenCalled();
+          });
+        case 1:
+          event = onAbm.mock.calls[0][0];
+          expect(event.detail.agentValues.initialSection).toBe('knowledge');
+          document.removeEventListener('abm-agent-modal-set-values', onAbm);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","waitFor","fetchAgentDetailAndParsedForAbm","ChatAICreateAgentActions","jsx","_jsx","jest","mock","fn","useSnackBarManager","handleSnackbarError","fetchDetail","flags","window","describe","beforeEach","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","mockResolvedValue","chatAgent","id","name","emoji","type","abmParsed","afterEach","it","_renderWithProviders","agentId","container","expect","toBeEmptyDOMElement","_asyncToGenerator","_regeneratorRuntime","mark","_callee","onOpen","wrap","_context","prev","next","document","addEventListener","click","getByRole","toHaveBeenCalledWith","toHaveBeenCalled","removeEventListener","stop","_callee2","onAbm","event","_context2","calls","detail","agentValues","initialSection","toBe"],"sources":["../../../../src/components/molecules/ChatAIMessages/ChatAICreateAgentActions.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils'\nimport { fetchAgentDetailAndParsedForAbm } from '../../../services/maia/Agents/fetchAgentDetail'\nimport { ChatAICreateAgentActions } from './ChatAICreateAgentActions'\n\njest.mock('../../../services/maia/Agents/fetchAgentDetail', () => ({\n  fetchAgentDetailAndParsedForAbm: jest.fn(),\n}))\n\njest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError: jest.fn() }),\n}))\n\nconst fetchDetail = fetchAgentDetailAndParsedForAbm as jest.MockedFunction<typeof fetchAgentDetailAndParsedForAbm>\n\ntype MultiAgentWindow = Window & { MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS?: boolean }\n\nconst flags = window as MultiAgentWindow\n\ndescribe('ChatAICreateAgentActions', () => {\n  beforeEach(() => {\n    flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true\n    fetchDetail.mockResolvedValue({\n      chatAgent: { id: 'a1', name: 'Nuevo', emoji: '✨', type: 'custom' },\n      abmParsed: { id: 'a1', name: 'Nuevo' },\n    } as Awaited<ReturnType<typeof fetchAgentDetailAndParsedForAbm>>)\n  })\n\n  afterEach(() => {\n    delete flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS\n  })\n\n  it('returns null without the multi-agents flag', () => {\n    delete flags.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS\n    const { container } = renderWithProviders(<ChatAICreateAgentActions agentId=\"a1\" />)\n\n    expect(container).toBeEmptyDOMElement()\n  })\n\n  it('opens a new chat with the created agent', async () => {\n    const onOpen = jest.fn()\n    document.addEventListener('maia-open-new-chat-with-agent', onOpen)\n\n    renderWithProviders(<ChatAICreateAgentActions agentId=\"a1\" />)\n    fireEvent.click(screen.getByRole('button', { name: 'chat.createAgentActionStartChat' }))\n\n    await waitFor(() => {\n      expect(fetchDetail).toHaveBeenCalledWith('a1')\n      expect(onOpen).toHaveBeenCalled()\n    })\n\n    document.removeEventListener('maia-open-new-chat-with-agent', onOpen)\n  })\n\n  it('opens the ABM on the knowledge section', async () => {\n    const onAbm = jest.fn()\n    document.addEventListener('abm-agent-modal-set-values', onAbm)\n\n    renderWithProviders(<ChatAICreateAgentActions agentId=\"a1\" />)\n    fireEvent.click(screen.getByRole('button', { name: 'chat.createAgentActionKnowledge' }))\n\n    await waitFor(() => {\n      expect(onAbm).toHaveBeenCalled()\n    })\n\n    const event = onAbm.mock.calls[0][0] as CustomEvent\n    expect(event.detail.agentValues.initialSection).toBe('knowledge')\n\n    document.removeEventListener('abm-agent-modal-set-values', onAbm)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/ChatAIMessages/ChatAIMessages.helpers.js

@@ -0,0 +1,54 @@
+export var turnAnchorOffset = function turnAnchorOffset(viewportHeight) {
+  return Math.min(viewportHeight * 0.18, 200);
+};
+export var TURN_SCROLL_DURATION_MS = 600;
+export var TURN_SCROLL_MAX_DURATION_MS = 800;
+export var TURN_SCROLL_LONG_DISTANCE_PX = 1200;
+export var computeTurnScrollDurationMs = function computeTurnScrollDurationMs(distance) {
+  return TURN_SCROLL_DURATION_MS + (TURN_SCROLL_MAX_DURATION_MS - TURN_SCROLL_DURATION_MS) * Math.min(1, Math.abs(distance) / TURN_SCROLL_LONG_DISTANCE_PX);
+};
+export var computeDistanceFromBottom = function computeDistanceFromBottom(scrollHeight, spacerHeight, scrollTop, clientHeight) {
+  return scrollHeight - spacerHeight - scrollTop - clientHeight;
+};
+export var shouldShowScrollToBottom = function shouldShowScrollToBottom(distanceFromBottom) {
+  var threshold = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 50;
+  return distanceFromBottom > threshold;
+};
+export var extractFeedbackSessionId = function extractFeedbackSessionId(messageId) {
+  return messageId.split('-').filter(function (questionId) {
+    return questionId !== 'answer';
+  }).join('-');
+};
+var AUDIO_EXTENSIONS = ['.flac', '.m4a', '.mp3', '.mp4', '.oga', '.ogg', '.wav', '.webm'];
+var AUDIO_TYPES = ['flac', 'm4a', 'mp3', 'mp4', 'oga', 'ogg', 'wav', 'webm'];
+export var isAudioAttachment = function isAudioAttachment(attachment) {
+  var _attachment$type, _attachment$name;
+  var attachmentType = (attachment === null || attachment === void 0 || (_attachment$type = attachment.type) === null || _attachment$type === void 0 ? void 0 : _attachment$type.toLowerCase()) || '';
+  var attachmentName = (attachment === null || attachment === void 0 || (_attachment$name = attachment.name) === null || _attachment$name === void 0 ? void 0 : _attachment$name.toLowerCase()) || '';
+  return attachmentType.startsWith('audio/') || AUDIO_TYPES.includes(attachmentType) || AUDIO_EXTENSIONS.some(function (ext) {
+    return attachmentName.endsWith(ext);
+  });
+};
+export var canOpenAttachmentPreview = function canOpenAttachmentPreview(attachment) {
+  return attachment.file instanceof File || attachment.originalFile instanceof File || Boolean(attachment.url_thumbnail || attachment.url_original || attachment.url_file);
+};
+export var findLastQuestionId = function findLastQuestionId(messages) {
+  for (var index = messages.length - 1; index >= 0; index -= 1) {
+    var _messages$index;
+    var messageId = (_messages$index = messages[index]) === null || _messages$index === void 0 ? void 0 : _messages$index.id;
+    if (messageId !== null && messageId !== void 0 && messageId.startsWith('question-')) {
+      return messageId;
+    }
+  }
+  return null;
+};
+export var computeReservedTurnSpace = function computeReservedTurnSpace(clientHeight, turnHeight, viewportHeight) {
+  var offset = turnAnchorOffset(viewportHeight);
+  return Math.max(0, clientHeight - turnHeight - offset);
+};
+export var computeRemovableTurnSpace = function computeRemovableTurnSpace(scrollHeight, clientHeight, scrollTop, currentSpacerHeight) {
+  if (currentSpacerHeight <= 0) return currentSpacerHeight;
+  var removable = Math.max(0, scrollHeight - clientHeight - scrollTop);
+  return Math.max(0, currentSpacerHeight - removable);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["turnAnchorOffset","viewportHeight","Math","min","TURN_SCROLL_DURATION_MS","TURN_SCROLL_MAX_DURATION_MS","TURN_SCROLL_LONG_DISTANCE_PX","computeTurnScrollDurationMs","distance","abs","computeDistanceFromBottom","scrollHeight","spacerHeight","scrollTop","clientHeight","shouldShowScrollToBottom","distanceFromBottom","threshold","arguments","length","undefined","extractFeedbackSessionId","messageId","split","filter","questionId","join","AUDIO_EXTENSIONS","AUDIO_TYPES","isAudioAttachment","attachment","_attachment$type","_attachment$name","attachmentType","type","toLowerCase","attachmentName","name","startsWith","includes","some","ext","endsWith","canOpenAttachmentPreview","file","File","originalFile","Boolean","url_thumbnail","url_original","url_file","findLastQuestionId","messages","index","_messages$index","id","computeReservedTurnSpace","turnHeight","offset","max","computeRemovableTurnSpace","currentSpacerHeight","removable"],"sources":["../../../../src/components/molecules/ChatAIMessages/ChatAIMessages.helpers.ts"],"sourcesContent":["import type { AttachmentFile } from '../ChatFooter/ChatFooter'\n\nexport const turnAnchorOffset = (viewportHeight: number): number => Math.min(viewportHeight * 0.18, 200)\n\nexport const TURN_SCROLL_DURATION_MS = 600\nexport const TURN_SCROLL_MAX_DURATION_MS = 800\nexport const TURN_SCROLL_LONG_DISTANCE_PX = 1200\n\nexport const computeTurnScrollDurationMs = (distance: number): number =>\n  TURN_SCROLL_DURATION_MS +\n  (TURN_SCROLL_MAX_DURATION_MS - TURN_SCROLL_DURATION_MS) *\n    Math.min(1, Math.abs(distance) / TURN_SCROLL_LONG_DISTANCE_PX)\n\nexport const computeDistanceFromBottom = (\n  scrollHeight: number,\n  spacerHeight: number,\n  scrollTop: number,\n  clientHeight: number\n): number => scrollHeight - spacerHeight - scrollTop - clientHeight\n\nexport const shouldShowScrollToBottom = (distanceFromBottom: number, threshold = 50): boolean =>\n  distanceFromBottom > threshold\n\nexport const extractFeedbackSessionId = (messageId: string): string =>\n  messageId\n    .split('-')\n    .filter(questionId => questionId !== 'answer')\n    .join('-')\n\nconst AUDIO_EXTENSIONS = ['.flac', '.m4a', '.mp3', '.mp4', '.oga', '.ogg', '.wav', '.webm'] as const\nconst AUDIO_TYPES = ['flac', 'm4a', 'mp3', 'mp4', 'oga', 'ogg', 'wav', 'webm'] as const\n\nexport const isAudioAttachment = (attachment: Pick<AttachmentFile, 'type' | 'name'>): boolean => {\n  const attachmentType = attachment?.type?.toLowerCase() || ''\n  const attachmentName = attachment?.name?.toLowerCase() || ''\n\n  return (\n    attachmentType.startsWith('audio/') ||\n    AUDIO_TYPES.includes(attachmentType as (typeof AUDIO_TYPES)[number]) ||\n    AUDIO_EXTENSIONS.some(ext => attachmentName.endsWith(ext))\n  )\n}\n\nexport const canOpenAttachmentPreview = (attachment: AttachmentFile): boolean =>\n  attachment.file instanceof File ||\n  attachment.originalFile instanceof File ||\n  Boolean(attachment.url_thumbnail || attachment.url_original || attachment.url_file)\n\nexport const findLastQuestionId = (messages: Array<{ id?: string }>): string | null => {\n  for (let index = messages.length - 1; index >= 0; index -= 1) {\n    const messageId = messages[index]?.id\n    if (messageId?.startsWith('question-')) {\n      return messageId\n    }\n  }\n  return null\n}\n\nexport const computeReservedTurnSpace = (clientHeight: number, turnHeight: number, viewportHeight: number): number => {\n  const offset = turnAnchorOffset(viewportHeight)\n  return Math.max(0, clientHeight - turnHeight - offset)\n}\n\nexport const computeRemovableTurnSpace = (\n  scrollHeight: number,\n  clientHeight: number,\n  scrollTop: number,\n  currentSpacerHeight: number\n): number => {\n  if (currentSpacerHeight <= 0) return currentSpacerHeight\n  const removable = Math.max(0, scrollHeight - clientHeight - scrollTop)\n  return Math.max(0, currentSpacerHeight - removable)\n}\n"],"mappings":"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","ignoreList":[]}