@projectcor/maia-components 2.45.0 → 2.45.1-0

package/lib/components/molecules/ChatAIModal/components/ChatAiModalHeader/ChatAiModalHeader.spec.js

@@ -0,0 +1,241 @@
+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 { act, fireEvent, renderWithProviders, screen } from '../../../../../test/test-utils';
+import { GlobalContextTestProvider, testAgent } from '../../../../../test/global-context';
+import { ChatAIModalHeader } from './ChatAiModalHeader';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      openModal: 'OPEN_MODAL',
+      aiChatAgentSelect: 'AI_CHAT_AGENT_SELECT',
+      aiChatOpenAgentSelect: 'AI_CHAT_OPEN_AGENT_SELECT',
+      projectResumeExpand: 'PROJECT_RESUME_EXPAND',
+      aiChatSelectViewOptions: 'AI_CHAT_SELECT_VIEW',
+      aiChatMinimize: 'AI_CHAT_MINIMIZE'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+jest.mock('../../../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 1500;
+    }
+  };
+});
+jest.mock('../../../../../hooks/useResize', function () {
+  return {
+    useResizeListener: function useResizeListener() {
+      return {
+        showTooltip: false
+      };
+    }
+  };
+});
+jest.mock('../../../../../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        id: 99,
+        role_id: 3,
+        permissions: {
+          ai_agents: {
+            create: true
+          }
+        }
+      };
+    }
+  };
+});
+jest.mock('../../../../../constants/maiaTaskPanelAccess', function () {
+  return {
+    isMaiaCloneAgentsRoleBlocked: function isMaiaCloneAgentsRoleBlocked() {
+      return false;
+    }
+  };
+});
+jest.mock('../../../../atoms/Loader', function () {
+  return {
+    Loader: function Loader() {
+      return /*#__PURE__*/_jsx("div", {
+        children: "loader"
+      });
+    }
+  };
+});
+jest.mock('../ChatAiAgentOptions/ChatAiAgentOptions', function () {
+  return {
+    ChatAIAgentOption: function ChatAIAgentOption(_ref) {
+      var agent = _ref.agent,
+        handleSelectAgent = _ref.handleSelectAgent;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        onClick: function onClick() {
+          return handleSelectAgent(agent);
+        },
+        children: agent.name
+      });
+    }
+  };
+});
+var customAgent = {
+  id: '2',
+  name: 'Custom',
+  type: 'custom'
+};
+var baseProps = {
+  layoutMode: 'sidebar',
+  onLayoutModeChange: jest.fn(),
+  expanded: false,
+  handleMinimize: jest.fn(),
+  agents: [testAgent, customAgent],
+  hasError: false,
+  loading: false,
+  handleResetChat: jest.fn()
+};
+var openAgentSelector = function openAgentSelector() {
+  fireEvent.click(document.getElementById('chat-ai-modal-header-wrapper'));
+};
+describe('ChatAIModalHeader', function () {
+  var originalMultiAgents = window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS;
+  var originalChatAccess = window.MAIA_CHAT_AI_FEATURE_ACCESS;
+  beforeEach(function () {
+    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true;
+    window.MAIA_CHAT_AI_FEATURE_ACCESS = true;
+    baseProps.onLayoutModeChange.mockClear();
+    baseProps.handleMinimize.mockClear();
+    baseProps.handleResetChat.mockClear();
+  });
+  afterEach(function () {
+    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = originalMultiAgents;
+    window.MAIA_CHAT_AI_FEATURE_ACCESS = originalChatAccess;
+  });
+  it('calls handleMinimize from the minimize control', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread({}, baseProps))
+    }));
+    var minimizeTooltip = screen.getByTitle('globals.minimize');
+    fireEvent.click(minimizeTooltip.querySelector('button'));
+    expect(baseProps.handleMinimize).toHaveBeenCalled();
+  });
+  it('shows the create-agent button in my agents section when allowed', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        isMyAgentsSection: true
+      }))
+    }));
+    expect(screen.getByRole('button', {
+      name: 'openAgentCreator'
+    })).toBeInTheDocument();
+  });
+  it('invokes onBack when the back button is visible', function () {
+    var onBack = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        showBackButton: true,
+        onBack: onBack
+      }))
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'back'
+    }));
+    expect(onBack).toHaveBeenCalled();
+  });
+  it('opens the layout menu and switches to fullscreen', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread({}, baseProps))
+    }));
+    var layoutMenu = screen.getByTitle('layoutMenuTooltip');
+    fireEvent.click(layoutMenu.querySelector('button'));
+    expect(screen.getByRole('menu')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', {
+      name: 'layoutFullscreen'
+    }));
+    expect(baseProps.onLayoutModeChange).toHaveBeenCalledWith('fullscreen');
+    expect(screen.queryByRole('menu')).not.toBeInTheDocument();
+  });
+  it('dispatches the create-agent event from the header button', function () {
+    var listener = jest.fn();
+    document.addEventListener('abm-agent-modal-set-values', listener);
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        isMyAgentsSection: true
+      }))
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'openAgentCreator'
+    }));
+    expect(listener).toHaveBeenCalled();
+    document.removeEventListener('abm-agent-modal-set-values', listener);
+  });
+  it('hides the header create button when multi-agents access is off', function () {
+    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false;
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        isMyAgentsSection: true
+      }))
+    }));
+    expect(screen.queryByRole('button', {
+      name: 'openAgentCreator'
+    })).not.toBeInTheDocument();
+  });
+  it('shows the my agents section title when no agent is selected', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        agent: null
+      },
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        isMyAgentsSection: true
+      }))
+    }));
+    expect(screen.getByText('marketplace.myAgentsTitle')).toBeInTheDocument();
+  });
+  it('selects a custom agent and resets the chat', function () {
+    jest.useFakeTimers();
+    var selectAgent = jest.fn();
+    var onAgentSelected = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        selectAgent: selectAgent
+      },
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        onAgentSelected: onAgentSelected
+      }))
+    }));
+    openAgentSelector();
+    fireEvent.click(screen.getByRole('button', {
+      name: 'Custom'
+    }));
+    expect(selectAgent).toHaveBeenCalledWith(customAgent);
+    act(function () {
+      jest.advanceTimersByTime(100);
+    });
+    expect(baseProps.handleResetChat).toHaveBeenCalled();
+    expect(onAgentSelected).toHaveBeenCalledWith(customAgent);
+    jest.useRealTimers();
+  });
+  it('opens create agent from the selector dropdown', function () {
+    var listener = jest.fn();
+    document.addEventListener('abm-agent-modal-set-values', listener);
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread({}, baseProps))
+    }));
+    openAgentSelector();
+    fireEvent.click(screen.getByText('createAgent'));
+    expect(listener).toHaveBeenCalled();
+    document.removeEventListener('abm-agent-modal-set-values', listener);
+  });
+  it('does not render the agent selector when hideAgentSelector is true', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIModalHeader, _objectSpread(_objectSpread({}, baseProps), {}, {
+        hideAgentSelector: true
+      }))
+    }));
+    expect(document.getElementById('chat-ai-modal-header-wrapper')).not.toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","fireEvent","renderWithProviders","screen","GlobalContextTestProvider","testAgent","ChatAIModalHeader","jsx","_jsx","jest","mock","EVENTS","openModal","aiChatAgentSelect","aiChatOpenAgentSelect","projectResumeExpand","aiChatSelectViewOptions","aiChatMinimize","useEvent","fn","useMaiaTaskPanelZIndex","useResizeListener","showTooltip","useUser","id","role_id","permissions","ai_agents","create","isMaiaCloneAgentsRoleBlocked","Loader","children","ChatAIAgentOption","_ref","agent","handleSelectAgent","type","onClick","name","customAgent","baseProps","layoutMode","onLayoutModeChange","expanded","handleMinimize","agents","hasError","loading","handleResetChat","openAgentSelector","click","document","getElementById","describe","originalMultiAgents","window","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","originalChatAccess","MAIA_CHAT_AI_FEATURE_ACCESS","beforeEach","mockClear","afterEach","it","_objectSpread","minimizeTooltip","getByTitle","querySelector","expect","toHaveBeenCalled","isMyAgentsSection","getByRole","toBeInTheDocument","onBack","showBackButton","layoutMenu","toHaveBeenCalledWith","queryByRole","not","listener","addEventListener","removeEventListener","value","getByText","useFakeTimers","selectAgent","onAgentSelected","advanceTimersByTime","useRealTimers","hideAgentSelector"],"sources":["../../../../../../src/components/molecules/ChatAIModal/components/ChatAiModalHeader/ChatAiModalHeader.spec.tsx"],"sourcesContent":["import { act, fireEvent, renderWithProviders, screen } from '../../../../../test/test-utils'\nimport { GlobalContextTestProvider, testAgent } from '../../../../../test/global-context'\nimport type { Agent } from '../../../../../types/agent'\nimport { ChatAIModalHeader } from './ChatAiModalHeader'\n\njest.mock('../../../../../hooks/useEvent', () => ({\n  EVENTS: {\n    openModal: 'OPEN_MODAL',\n    aiChatAgentSelect: 'AI_CHAT_AGENT_SELECT',\n    aiChatOpenAgentSelect: 'AI_CHAT_OPEN_AGENT_SELECT',\n    projectResumeExpand: 'PROJECT_RESUME_EXPAND',\n    aiChatSelectViewOptions: 'AI_CHAT_SELECT_VIEW',\n    aiChatMinimize: 'AI_CHAT_MINIMIZE',\n  },\n  useEvent: () => jest.fn(),\n}))\n\njest.mock('../../../../../hooks/useMaiaTaskPanelZIndex', () => ({\n  useMaiaTaskPanelZIndex: () => 1500,\n}))\n\njest.mock('../../../../../hooks/useResize', () => ({\n  useResizeListener: () => ({ showTooltip: false }),\n}))\n\njest.mock('../../../../../context/cor-user', () => ({\n  useUser: () => ({\n    id: 99,\n    role_id: 3,\n    permissions: { ai_agents: { create: true } },\n  }),\n}))\n\njest.mock('../../../../../constants/maiaTaskPanelAccess', () => ({\n  isMaiaCloneAgentsRoleBlocked: () => false,\n}))\n\njest.mock('../../../../atoms/Loader', () => ({\n  Loader: () => <div>loader</div>,\n}))\n\njest.mock('../ChatAiAgentOptions/ChatAiAgentOptions', () => ({\n  ChatAIAgentOption: ({ agent, handleSelectAgent }: { agent: Agent; handleSelectAgent: (selected: Agent) => void }) => (\n    <button type=\"button\" onClick={() => handleSelectAgent(agent)}>\n      {agent.name}\n    </button>\n  ),\n}))\n\nconst customAgent: Agent = { id: '2', name: 'Custom', type: 'custom' }\n\nconst baseProps = {\n  layoutMode: 'sidebar' as const,\n  onLayoutModeChange: jest.fn(),\n  expanded: false,\n  handleMinimize: jest.fn(),\n  agents: [testAgent, customAgent],\n  hasError: false,\n  loading: false,\n  handleResetChat: jest.fn(),\n}\n\nconst openAgentSelector = () => {\n  fireEvent.click(document.getElementById('chat-ai-modal-header-wrapper')!)\n}\n\ndescribe('ChatAIModalHeader', () => {\n  const originalMultiAgents = window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS\n  const originalChatAccess = window.MAIA_CHAT_AI_FEATURE_ACCESS\n\n  beforeEach(() => {\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true\n    window.MAIA_CHAT_AI_FEATURE_ACCESS = true\n    baseProps.onLayoutModeChange.mockClear()\n    baseProps.handleMinimize.mockClear()\n    baseProps.handleResetChat.mockClear()\n  })\n\n  afterEach(() => {\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = originalMultiAgents\n    window.MAIA_CHAT_AI_FEATURE_ACCESS = originalChatAccess\n  })\n\n  it('calls handleMinimize from the minimize control', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} />\n      </GlobalContextTestProvider>\n    )\n\n    const minimizeTooltip = screen.getByTitle('globals.minimize')\n    fireEvent.click(minimizeTooltip.querySelector('button') as HTMLButtonElement)\n    expect(baseProps.handleMinimize).toHaveBeenCalled()\n  })\n\n  it('shows the create-agent button in my agents section when allowed', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} isMyAgentsSection />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByRole('button', { name: 'openAgentCreator' })).toBeInTheDocument()\n  })\n\n  it('invokes onBack when the back button is visible', () => {\n    const onBack = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} showBackButton onBack={onBack} />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'back' }))\n    expect(onBack).toHaveBeenCalled()\n  })\n\n  it('opens the layout menu and switches to fullscreen', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} />\n      </GlobalContextTestProvider>\n    )\n\n    const layoutMenu = screen.getByTitle('layoutMenuTooltip')\n    fireEvent.click(layoutMenu.querySelector('button') as HTMLButtonElement)\n    expect(screen.getByRole('menu')).toBeInTheDocument()\n\n    fireEvent.click(screen.getByRole('button', { name: 'layoutFullscreen' }))\n\n    expect(baseProps.onLayoutModeChange).toHaveBeenCalledWith('fullscreen')\n    expect(screen.queryByRole('menu')).not.toBeInTheDocument()\n  })\n\n  it('dispatches the create-agent event from the header button', () => {\n    const listener = jest.fn()\n    document.addEventListener('abm-agent-modal-set-values', listener)\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} isMyAgentsSection />\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'openAgentCreator' }))\n\n    expect(listener).toHaveBeenCalled()\n    document.removeEventListener('abm-agent-modal-set-values', listener)\n  })\n\n  it('hides the header create button when multi-agents access is off', () => {\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} isMyAgentsSection />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.queryByRole('button', { name: 'openAgentCreator' })).not.toBeInTheDocument()\n  })\n\n  it('shows the my agents section title when no agent is selected', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ agent: null }}>\n        <ChatAIModalHeader {...baseProps} isMyAgentsSection />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('marketplace.myAgentsTitle')).toBeInTheDocument()\n  })\n\n  it('selects a custom agent and resets the chat', () => {\n    jest.useFakeTimers()\n    const selectAgent = jest.fn()\n    const onAgentSelected = jest.fn()\n\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ selectAgent }}>\n        <ChatAIModalHeader {...baseProps} onAgentSelected={onAgentSelected} />\n      </GlobalContextTestProvider>\n    )\n\n    openAgentSelector()\n    fireEvent.click(screen.getByRole('button', { name: 'Custom' }))\n\n    expect(selectAgent).toHaveBeenCalledWith(customAgent)\n\n    act(() => {\n      jest.advanceTimersByTime(100)\n    })\n\n    expect(baseProps.handleResetChat).toHaveBeenCalled()\n    expect(onAgentSelected).toHaveBeenCalledWith(customAgent)\n\n    jest.useRealTimers()\n  })\n\n  it('opens create agent from the selector dropdown', () => {\n    const listener = jest.fn()\n    document.addEventListener('abm-agent-modal-set-values', listener)\n\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} />\n      </GlobalContextTestProvider>\n    )\n\n    openAgentSelector()\n    fireEvent.click(screen.getByText('createAgent'))\n\n    expect(listener).toHaveBeenCalled()\n    document.removeEventListener('abm-agent-modal-set-values', listener)\n  })\n\n  it('does not render the agent selector when hideAgentSelector is true', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIModalHeader {...baseProps} hideAgentSelector />\n      </GlobalContextTestProvider>\n    )\n\n    expect(document.getElementById('chat-ai-modal-header-wrapper')).not.toBeInTheDocument()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/ChatAIModal/components/MaiaMinimizedPill/MaiaMinimizedPill.spec.js

@@ -0,0 +1,37 @@
+import { renderWithProviders, screen } from '../../../../../test/test-utils';
+import { MaiaMinimizedPill } from './MaiaMinimizedPill';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../../../hooks/useMinimizedPillBottomOffset', function () {
+  return {
+    useMinimizedPillBottomOffset: function useMinimizedPillBottomOffset() {
+      return 16;
+    }
+  };
+});
+describe('MaiaMinimizedPill', function () {
+  it('shows a novelty dot without a numeric badge', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaMinimizedPill, {
+      showNoveltyDot: true,
+      isStreaming: false,
+      onRestore: jest.fn()
+    }));
+    var button = screen.getByRole('button', {
+      name: 'conversations.minimizedOpen'
+    });
+    expect(button.querySelector('[aria-hidden="true"]')).toBeInTheDocument();
+    expect(button).not.toHaveTextContent('9');
+  });
+  it('calls onRestore when clicked', function () {
+    var onRestore = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaMinimizedPill, {
+      showNoveltyDot: false,
+      isStreaming: false,
+      onRestore: onRestore
+    }));
+    screen.getByRole('button', {
+      name: 'conversations.minimizedOpen'
+    }).click();
+    expect(onRestore).toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJyZW5kZXJXaXRoUHJvdmlkZXJzIiwic2NyZWVuIiwiTWFpYU1pbmltaXplZFBpbGwiLCJqc3giLCJfanN4IiwiamVzdCIsIm1vY2siLCJ1c2VNaW5pbWl6ZWRQaWxsQm90dG9tT2Zmc2V0IiwiZGVzY3JpYmUiLCJpdCIsInNob3dOb3ZlbHR5RG90IiwiaXNTdHJlYW1pbmciLCJvblJlc3RvcmUiLCJmbiIsImJ1dHRvbiIsImdldEJ5Um9sZSIsIm5hbWUiLCJleHBlY3QiLCJxdWVyeVNlbGVjdG9yIiwidG9CZUluVGhlRG9jdW1lbnQiLCJub3QiLCJ0b0hhdmVUZXh0Q29udGVudCIsImNsaWNrIiwidG9IYXZlQmVlbkNhbGxlZCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL21vbGVjdWxlcy9DaGF0QUlNb2RhbC9jb21wb25lbnRzL01haWFNaW5pbWl6ZWRQaWxsL01haWFNaW5pbWl6ZWRQaWxsLnNwZWMudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHJlbmRlcldpdGhQcm92aWRlcnMsIHNjcmVlbiB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL3Rlc3QvdGVzdC11dGlscydcbmltcG9ydCB7IE1haWFNaW5pbWl6ZWRQaWxsIH0gZnJvbSAnLi9NYWlhTWluaW1pemVkUGlsbCdcblxuamVzdC5tb2NrKCcuLi8uLi8uLi8uLi8uLi9ob29rcy91c2VNaW5pbWl6ZWRQaWxsQm90dG9tT2Zmc2V0JywgKCkgPT4gKHtcbiAgdXNlTWluaW1pemVkUGlsbEJvdHRvbU9mZnNldDogKCkgPT4gMTYsXG59KSlcblxuZGVzY3JpYmUoJ01haWFNaW5pbWl6ZWRQaWxsJywgKCkgPT4ge1xuICBpdCgnc2hvd3MgYSBub3ZlbHR5IGRvdCB3aXRob3V0IGEgbnVtZXJpYyBiYWRnZScsICgpID0+IHtcbiAgICByZW5kZXJXaXRoUHJvdmlkZXJzKDxNYWlhTWluaW1pemVkUGlsbCBzaG93Tm92ZWx0eURvdCBpc1N0cmVhbWluZz17ZmFsc2V9IG9uUmVzdG9yZT17amVzdC5mbigpfSAvPilcblxuICAgIGNvbnN0IGJ1dHRvbiA9IHNjcmVlbi5nZXRCeVJvbGUoJ2J1dHRvbicsIHsgbmFtZTogJ2NvbnZlcnNhdGlvbnMubWluaW1pemVkT3BlbicgfSlcbiAgICBleHBlY3QoYnV0dG9uLnF1ZXJ5U2VsZWN0b3IoJ1thcmlhLWhpZGRlbj1cInRydWVcIl0nKSkudG9CZUluVGhlRG9jdW1lbnQoKVxuICAgIGV4cGVjdChidXR0b24pLm5vdC50b0hhdmVUZXh0Q29udGVudCgnOScpXG4gIH0pXG5cbiAgaXQoJ2NhbGxzIG9uUmVzdG9yZSB3aGVuIGNsaWNrZWQnLCAoKSA9PiB7XG4gICAgY29uc3Qgb25SZXN0b3JlID0gamVzdC5mbigpXG4gICAgcmVuZGVyV2l0aFByb3ZpZGVycyg8TWFpYU1pbmltaXplZFBpbGwgc2hvd05vdmVsdHlEb3Q9e2ZhbHNlfSBpc1N0cmVhbWluZz17ZmFsc2V9IG9uUmVzdG9yZT17b25SZXN0b3JlfSAvPilcblxuICAgIHNjcmVlbi5nZXRCeVJvbGUoJ2J1dHRvbicsIHsgbmFtZTogJ2NvbnZlcnNhdGlvbnMubWluaW1pemVkT3BlbicgfSkuY2xpY2soKVxuICAgIGV4cGVjdChvblJlc3RvcmUpLnRvSGF2ZUJlZW5DYWxsZWQoKVxuICB9KVxufSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsbUJBQW1CLEVBQUVDLE1BQU0sUUFBUSxnQ0FBZ0M7QUFDNUUsU0FBU0MsaUJBQWlCLFFBQVEscUJBQXFCO0FBQUEsU0FBQUMsR0FBQSxJQUFBQyxJQUFBO0FBRXZEQyxJQUFJLENBQUNDLElBQUksQ0FBQyxtREFBbUQsRUFBRTtFQUFBLE9BQU87SUFDcEVDLDRCQUE0QixFQUFFLFNBQTlCQSw0QkFBNEJBLENBQUE7TUFBQSxPQUFRLEVBQUU7SUFBQTtFQUN4QyxDQUFDO0FBQUEsQ0FBQyxDQUFDO0FBRUhDLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRSxZQUFNO0VBQ2xDQyxFQUFFLENBQUMsNkNBQTZDLEVBQUUsWUFBTTtJQUN0RFQsbUJBQW1CLGNBQUNJLElBQUEsQ0FBQ0YsaUJBQWlCO01BQUNRLGNBQWM7TUFBQ0MsV0FBVyxFQUFFLEtBQU07TUFBQ0MsU0FBUyxFQUFFUCxJQUFJLENBQUNRLEVBQUUsQ0FBQztJQUFFLENBQUUsQ0FBQyxDQUFDO0lBRW5HLElBQU1DLE1BQU0sR0FBR2IsTUFBTSxDQUFDYyxTQUFTLENBQUMsUUFBUSxFQUFFO01BQUVDLElBQUksRUFBRTtJQUE4QixDQUFDLENBQUM7SUFDbEZDLE1BQU0sQ0FBQ0gsTUFBTSxDQUFDSSxhQUFhLENBQUMsc0JBQXNCLENBQUMsQ0FBQyxDQUFDQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3hFRixNQUFNLENBQUNILE1BQU0sQ0FBQyxDQUFDTSxHQUFHLENBQUNDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQztFQUMzQyxDQUFDLENBQUM7RUFFRlosRUFBRSxDQUFDLDhCQUE4QixFQUFFLFlBQU07SUFDdkMsSUFBTUcsU0FBUyxHQUFHUCxJQUFJLENBQUNRLEVBQUUsQ0FBQyxDQUFDO0lBQzNCYixtQkFBbUIsY0FBQ0ksSUFBQSxDQUFDRixpQkFBaUI7TUFBQ1EsY0FBYyxFQUFFLEtBQU07TUFBQ0MsV0FBVyxFQUFFLEtBQU07TUFBQ0MsU0FBUyxFQUFFQTtJQUFVLENBQUUsQ0FBQyxDQUFDO0lBRTNHWCxNQUFNLENBQUNjLFNBQVMsQ0FBQyxRQUFRLEVBQUU7TUFBRUMsSUFBSSxFQUFFO0lBQThCLENBQUMsQ0FBQyxDQUFDTSxLQUFLLENBQUMsQ0FBQztJQUMzRUwsTUFBTSxDQUFDTCxTQUFTLENBQUMsQ0FBQ1csZ0JBQWdCLENBQUMsQ0FBQztFQUN0QyxDQUFDLENBQUM7QUFDSixDQUFDLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/components/molecules/ChatAIModal/constants.spec.js

@@ -0,0 +1,16 @@
+import { buildHandlers, options } from './constants';
+describe('ChatAIModal constants', function () {
+  it('buildHandlers clears errors and switches options', function () {
+    var setCurrentOption = jest.fn();
+    var setHasError = jest.fn();
+    var handlers = buildHandlers(setCurrentOption, setHasError);
+    handlers[options.home]();
+    expect(setHasError).toHaveBeenCalledWith(false);
+    expect(setCurrentOption).toHaveBeenCalledWith(options.home);
+    handlers[options.chat]();
+    expect(setCurrentOption).toHaveBeenCalledWith(options.chat);
+    handlers[options.mySkills]();
+    expect(setCurrentOption).toHaveBeenCalledWith(options.mySkills);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/molecules/ChatAIModal/floatingPanelMotion/FloatingPanelMotion.spec.js

@@ -0,0 +1,22 @@
+import { useMotionValue } from 'framer-motion';
+import { renderWithProviders, screen } from '../../../../test/test-utils';
+import { FloatingPanelMotion } from './FloatingPanelMotion';
+import { jsx as _jsx } from "react/jsx-runtime";
+var MotionHost = function MotionHost(_ref) {
+  var expanded = _ref.expanded;
+  var tilt = useMotionValue(12);
+  return /*#__PURE__*/_jsx(FloatingPanelMotion, {
+    tilt: tilt,
+    expanded: expanded,
+    children: /*#__PURE__*/_jsx("span", {
+      children: "floating-panel"
+    })
+  });
+};
+describe('FloatingPanelMotion', function () {
+  it('renders children inside the motion root', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MotionHost, {}));
+    expect(screen.getByText('floating-panel')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/molecules/ChatAIModal/floatingPanelMotion/useFloatingPanelDragTilt.spec.js

@@ -0,0 +1,67 @@
+import { act, renderHook } from '@testing-library/react';
+import { useFloatingPanelDragTilt } from './useFloatingPanelDragTilt';
+import { FLOATING_DRAG_TILT_IDLE_MS } from './constants';
+var tiltSet = jest.fn();
+jest.mock('framer-motion', function () {
+  return {
+    useSpring: function useSpring() {
+      return {
+        set: tiltSet
+      };
+    }
+  };
+});
+describe('useFloatingPanelDragTilt', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+  });
+  it('resets tilt when floating mode is disabled', function () {
+    var _renderHook = renderHook(function (_ref) {
+        var isFloating = _ref.isFloating;
+        return useFloatingPanelDragTilt(isFloating);
+      }, {
+        initialProps: {
+          isFloating: true
+        }
+      }),
+      rerender = _renderHook.rerender;
+    rerender({
+      isFloating: false
+    });
+    expect(tiltSet).toHaveBeenCalledWith(0);
+  });
+  it('updates tilt while tracking pointer movement', function () {
+    var _renderHook2 = renderHook(function () {
+        return useFloatingPanelDragTilt(true);
+      }),
+      result = _renderHook2.result;
+    act(function () {
+      result.current.startPointerTracking(0, 0);
+      result.current.samplePointerMove(24, 0);
+    });
+    expect(tiltSet).toHaveBeenCalled();
+  });
+  it('returns tilt to zero after idle timeout and on pointer end', function () {
+    var _renderHook3 = renderHook(function () {
+        return useFloatingPanelDragTilt(true);
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current.startPointerTracking(0, 0);
+      result.current.samplePointerMove(12, 4);
+    });
+    act(function () {
+      jest.advanceTimersByTime(FLOATING_DRAG_TILT_IDLE_MS);
+    });
+    expect(tiltSet).toHaveBeenCalledWith(0);
+    act(function () {
+      result.current.endPointerTracking();
+    });
+    expect(tiltSet).toHaveBeenCalledWith(0);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/molecules/ChatAIModal/layout.spec.js

@@ -0,0 +1,72 @@
+import { getMaiaFloatingPanelWidthPx, getSectionForcedLayoutMode, isMaiaChatModalLayoutMode, MAIA_CHAT_LAYOUT_STORAGE_KEY, MAIA_FLOATING_BREAKPOINT_LARGE, MAIA_FLOATING_BREAKPOINT_XXL, resolveInitialMaiaChatLayoutMode, setStoredMaiaChatLayoutMode } from './layout';
+describe('ChatAIModal layout', function () {
+  afterEach(function () {
+    window.localStorage.removeItem(MAIA_CHAT_LAYOUT_STORAGE_KEY);
+  });
+  describe('isMaiaChatModalLayoutMode', function () {
+    it('accepts known layout modes only', function () {
+      expect(isMaiaChatModalLayoutMode('sidebar')).toBe(true);
+      expect(isMaiaChatModalLayoutMode('floating')).toBe(true);
+      expect(isMaiaChatModalLayoutMode('invalid')).toBe(false);
+    });
+  });
+  describe('getSectionForcedLayoutMode', function () {
+    it('forces floating for task, planner and banner FAQ', function () {
+      expect(getSectionForcedLayoutMode({
+        section: 'task'
+      })).toBe('floating');
+      expect(getSectionForcedLayoutMode({
+        section: 'planner'
+      })).toBe('floating');
+      expect(getSectionForcedLayoutMode({
+        section: 'header',
+        bannerEntryFaq: {
+          faqTitle: ' FAQ '
+        }
+      })).toBe('floating');
+    });
+    it('returns null when no section rule applies', function () {
+      expect(getSectionForcedLayoutMode({
+        section: 'header'
+      })).toBeNull();
+    });
+  });
+  describe('resolveInitialMaiaChatLayoutMode', function () {
+    it('prefers section rules over stored preference', function () {
+      setStoredMaiaChatLayoutMode('fullscreen');
+      expect(resolveInitialMaiaChatLayoutMode({
+        section: 'task'
+      })).toBe('floating');
+    });
+    it('falls back to stored mode or sidebar', function () {
+      setStoredMaiaChatLayoutMode('fullscreen');
+      expect(resolveInitialMaiaChatLayoutMode({
+        section: 'header'
+      })).toBe('fullscreen');
+      window.localStorage.removeItem(MAIA_CHAT_LAYOUT_STORAGE_KEY);
+      expect(resolveInitialMaiaChatLayoutMode({
+        section: 'project'
+      })).toBe('sidebar');
+    });
+  });
+  describe('getMaiaFloatingPanelWidthPx', function () {
+    it('scales width with viewport breakpoints', function () {
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: 1280
+      });
+      expect(getMaiaFloatingPanelWidthPx()).toBe(480);
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: MAIA_FLOATING_BREAKPOINT_LARGE
+      });
+      expect(getMaiaFloatingPanelWidthPx()).toBe(600);
+      Object.defineProperty(window, 'innerWidth', {
+        configurable: true,
+        value: MAIA_FLOATING_BREAKPOINT_XXL
+      });
+      expect(getMaiaFloatingPanelWidthPx()).toBe(720);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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