@projectcor/maia-components 2.50.0 → 2.50.1-0

package/lib/hooks/useMinimizedPillBottomOffset.spec.js

@@ -0,0 +1,89 @@
+import { act, renderHook } from '@testing-library/react';
+import { GlobalContextTestProvider } from '../test/global-context';
+import { useMinimizedPillBottomOffset } from './useMinimizedPillBottomOffset';
+import { DEFAULT_BOTTOM_PX } from './useMinimizedPillBottomOffset.helpers';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('useMinimizedPillBottomOffset', function () {
+  beforeEach(function () {
+    Object.defineProperty(window, 'innerHeight', {
+      configurable: true,
+      value: 800
+    });
+    Object.defineProperty(window, 'innerWidth', {
+      configurable: true,
+      value: 1024
+    });
+    jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (callback) {
+      callback(0);
+      return 1;
+    });
+    jest.spyOn(window, 'cancelAnimationFrame').mockImplementation(function () {
+      return undefined;
+    });
+  });
+  afterEach(function () {
+    jest.restoreAllMocks();
+  });
+  it('returns the default bottom when there are no avoid anchors', function () {
+    var _renderHook = renderHook(function () {
+        return useMinimizedPillBottomOffset();
+      }, {
+        wrapper: function wrapper(_ref) {
+          var children = _ref.children;
+          return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+            value: {},
+            children: children
+          });
+        }
+      }),
+      result = _renderHook.result;
+    expect(result.current).toBe(DEFAULT_BOTTOM_PX);
+  });
+  it('recomputes bottom offset when a colliding anchor is present', function () {
+    var anchor = document.createElement('div');
+    anchor.getBoundingClientRect = function () {
+      return {
+        left: 900,
+        top: 760,
+        right: 1020,
+        bottom: 790,
+        width: 120,
+        height: 30,
+        x: 900,
+        y: 760,
+        toJSON: function toJSON() {
+          return {};
+        }
+      };
+    };
+    jest.spyOn(document, 'querySelector').mockImplementation(function (selector) {
+      return selector === '#footer-bar' ? anchor : null;
+    });
+    jest.spyOn(window, 'getComputedStyle').mockReturnValue({
+      display: 'block',
+      visibility: 'visible',
+      opacity: '1'
+    });
+    var _renderHook2 = renderHook(function () {
+        return useMinimizedPillBottomOffset();
+      }, {
+        wrapper: function wrapper(_ref2) {
+          var children = _ref2.children;
+          return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+            value: {
+              minimizedPillAvoidAnchors: [{
+                selector: '#footer-bar'
+              }]
+            },
+            children: children
+          });
+        }
+      }),
+      result = _renderHook2.result;
+    act(function () {
+      window.dispatchEvent(new Event('resize'));
+    });
+    expect(result.current).toBeGreaterThan(DEFAULT_BOTTOM_PX);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useMinimizedPillNoveltyDot/useMinimizedPillNoveltyDot.spec.js

@@ -0,0 +1,67 @@
+import { renderHook } from '@testing-library/react';
+import { useMinimizedPillNoveltyDot } from './useMinimizedPillNoveltyDot';
+describe('useMinimizedPillNoveltyDot', function () {
+  it('shows the dot when minimized with unread and MAIA was never expanded', function () {
+    var _renderHook = renderHook(function () {
+        return useMinimizedPillNoveltyDot(true, 3);
+      }),
+      result = _renderHook.result;
+    expect(result.current).toBe(true);
+  });
+  it('hides the dot while MAIA is expanded', function () {
+    var _renderHook2 = renderHook(function () {
+        return useMinimizedPillNoveltyDot(false, 3);
+      }),
+      result = _renderHook2.result;
+    expect(result.current).toBe(false);
+  });
+  it('clears the dot after expand even if unread remain', function () {
+    var _renderHook3 = renderHook(function (_ref) {
+        var minimized = _ref.minimized,
+          unread = _ref.unread;
+        return useMinimizedPillNoveltyDot(minimized, unread);
+      }, {
+        initialProps: {
+          minimized: true,
+          unread: 3
+        }
+      }),
+      result = _renderHook3.result,
+      rerender = _renderHook3.rerender;
+    expect(result.current).toBe(true);
+    rerender({
+      minimized: false,
+      unread: 3
+    });
+    rerender({
+      minimized: true,
+      unread: 3
+    });
+    expect(result.current).toBe(false);
+  });
+  it('shows the dot again when unread increase while minimized', function () {
+    var _renderHook4 = renderHook(function (_ref2) {
+        var minimized = _ref2.minimized,
+          unread = _ref2.unread;
+        return useMinimizedPillNoveltyDot(minimized, unread);
+      }, {
+        initialProps: {
+          minimized: false,
+          unread: 2
+        }
+      }),
+      result = _renderHook4.result,
+      rerender = _renderHook4.rerender;
+    rerender({
+      minimized: true,
+      unread: 2
+    });
+    expect(result.current).toBe(false);
+    rerender({
+      minimized: true,
+      unread: 3
+    });
+    expect(result.current).toBe(true);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useModal/useModal.spec.js

@@ -0,0 +1,73 @@
+import { act, renderHook } from '@testing-library/react';
+import { createRef } from 'react';
+import { useModal } from './useModal';
+describe('useModal', function () {
+  it('starts closed unless initialOpen is true', function () {
+    var _renderHook = renderHook(function () {
+        return useModal({});
+      }),
+      closed = _renderHook.result;
+    expect(closed.current.isOpen).toBe(false);
+    var _renderHook2 = renderHook(function () {
+        return useModal({
+          initialOpen: true
+        });
+      }),
+      opened = _renderHook2.result;
+    expect(opened.current.isOpen).toBe(true);
+  });
+  it('toggles open state', function () {
+    var _renderHook3 = renderHook(function () {
+        return useModal({});
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current.toggleModal();
+    });
+    expect(result.current.isOpen).toBe(true);
+  });
+  it('closes on outside click and calls onClose', function () {
+    var onClose = jest.fn();
+    var _renderHook4 = renderHook(function () {
+        return useModal({
+          initialOpen: true,
+          onClose: onClose
+        });
+      }),
+      result = _renderHook4.result;
+    var outside = document.createElement('button');
+    document.body.appendChild(outside);
+    act(function () {
+      outside.dispatchEvent(new MouseEvent('click', {
+        bubbles: true
+      }));
+    });
+    outside.remove();
+    expect(result.current.isOpen).toBe(false);
+    expect(onClose).toHaveBeenCalled();
+  });
+  it('does not close when clicking inside the ref', function () {
+    var ref = /*#__PURE__*/createRef();
+    var node = document.createElement('div');
+    document.body.appendChild(node);
+    Object.defineProperty(ref, 'current', {
+      value: node,
+      writable: true
+    });
+    var _renderHook5 = renderHook(function () {
+        return useModal({
+          ref: ref,
+          initialOpen: true
+        });
+      }),
+      result = _renderHook5.result;
+    act(function () {
+      node.dispatchEvent(new MouseEvent('click', {
+        bubbles: true
+      }));
+    });
+    expect(result.current.isOpen).toBe(true);
+    node.remove();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useOrchestratorStream/useOrchestratorStream.helpers.spec.js

@@ -0,0 +1,138 @@
+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 { buildAskMaiaActivityOptions, buildAskMaiaStreamRequest, buildRetryStreamRequest } from './useOrchestratorStream.helpers';
+var baseAskPayload = {
+  message: 'Hola',
+  history: [],
+  projectId: null,
+  lang: 'es',
+  userId: 'u1',
+  companyId: 'c1',
+  chatId: 'session-1',
+  messageId: 'msg-1',
+  agentName: 'MAIA',
+  agentId: 'agent-1'
+};
+describe('useOrchestratorStream.helpers', function () {
+  it('buildAskMaiaStreamRequest omits optional fields when absent', function () {
+    expect(buildAskMaiaStreamRequest(baseAskPayload)).toEqual({
+      input: 'Hola',
+      history: [],
+      lang: 'es',
+      userId: 'u1',
+      companyId: 'c1',
+      chatId: 'session-1',
+      messageId: 'msg-1',
+      agentName: 'MAIA',
+      agentId: 'agent-1'
+    });
+  });
+  it('buildAskMaiaStreamRequest includes optional fields when present', function () {
+    var request = buildAskMaiaStreamRequest(_objectSpread(_objectSpread({}, baseAskPayload), {}, {
+      firstName: 'Ana',
+      lastName: 'Lopez',
+      feeId: 9,
+      projectId: 42,
+      attachments: [{
+        id: 'a1',
+        name: 'doc.pdf'
+      }],
+      projectName: 'Proyecto',
+      clientName: 'Cliente',
+      taskId: 7,
+      taskName: 'Tarea',
+      faqId: 'faq-1',
+      agentSuggestionId: 'sug-1',
+      fuaId: 'fua-1',
+      scId: 'sc-1',
+      agentEntity: 'global',
+      agentType: 'custom',
+      contextMessage: {
+        type: 'task',
+        id: '1',
+        label: 'Task'
+      },
+      contextData: {
+        foo: 'bar'
+      },
+      isWebSearchActive: true,
+      isDeepSearchActive: true,
+      isAutoApproveActive: true
+    }));
+    expect(request).toMatchObject({
+      firstName: 'Ana',
+      lastName: 'Lopez',
+      feeId: 9,
+      projectId: 42,
+      taskId: 7,
+      faqId: 'faq-1',
+      contextData: {
+        foo: 'bar'
+      },
+      isAutoApproveActive: true
+    });
+  });
+  it('buildAskMaiaActivityOptions reflects attachment count', function () {
+    expect(buildAskMaiaActivityOptions(baseAskPayload)).toEqual({
+      isWebSearchActive: undefined,
+      isDeepSearchActive: undefined,
+      hasAttachments: false,
+      attachmentsCount: 0
+    });
+    expect(buildAskMaiaActivityOptions(_objectSpread(_objectSpread({}, baseAskPayload), {}, {
+      attachments: [{
+        id: 'a1'
+      }, {
+        id: 'a2'
+      }],
+      isWebSearchActive: true
+    }))).toEqual({
+      isWebSearchActive: true,
+      isDeepSearchActive: undefined,
+      hasAttachments: true,
+      attachmentsCount: 2
+    });
+  });
+  it('buildRetryStreamRequest includes optional retry fields', function () {
+    expect(buildRetryStreamRequest({
+      chatId: 'session-1',
+      messageId: 'msg-2',
+      memorySessionId: 'mem-1',
+      lang: 'es',
+      agentId: 'agent-1',
+      agentName: 'MAIA'
+    })).toEqual({
+      sessionId: 'session-1',
+      memorySessionId: 'mem-1',
+      agentId: 'agent-1',
+      lang: 'es'
+    });
+    expect(buildRetryStreamRequest({
+      chatId: 'session-1',
+      messageId: 'msg-2',
+      memorySessionId: 'mem-1',
+      lang: 'es',
+      agentId: 'agent-1',
+      agentName: 'MAIA',
+      projectId: 42,
+      clientId: 5,
+      taskId: 9,
+      agentType: 'custom',
+      contextData: {
+        foo: 'bar'
+      },
+      isWebSearchActive: true,
+      isDeepSearchActive: true
+    })).toMatchObject({
+      projectId: 42,
+      clientId: 5,
+      taskId: 9,
+      agentType: 'custom',
+      contextData: {
+        foo: 'bar'
+      }
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["buildAskMaiaActivityOptions","buildAskMaiaStreamRequest","buildRetryStreamRequest","baseAskPayload","message","history","projectId","lang","userId","companyId","chatId","messageId","agentName","agentId","describe","it","expect","toEqual","input","request","_objectSpread","firstName","lastName","feeId","attachments","id","name","projectName","clientName","taskId","taskName","faqId","agentSuggestionId","fuaId","scId","agentEntity","agentType","contextMessage","type","label","contextData","foo","isWebSearchActive","isDeepSearchActive","isAutoApproveActive","toMatchObject","undefined","hasAttachments","attachmentsCount","memorySessionId","sessionId","clientId"],"sources":["../../../src/hooks/useOrchestratorStream/useOrchestratorStream.helpers.spec.ts"],"sourcesContent":["import {\n  buildAskMaiaActivityOptions,\n  buildAskMaiaStreamRequest,\n  buildRetryStreamRequest,\n} from './useOrchestratorStream.helpers'\n\nconst baseAskPayload = {\n  message: 'Hola',\n  history: [],\n  projectId: null as number | null,\n  lang: 'es',\n  userId: 'u1',\n  companyId: 'c1',\n  chatId: 'session-1',\n  messageId: 'msg-1',\n  agentName: 'MAIA',\n  agentId: 'agent-1',\n}\n\ndescribe('useOrchestratorStream.helpers', () => {\n  it('buildAskMaiaStreamRequest omits optional fields when absent', () => {\n    expect(buildAskMaiaStreamRequest(baseAskPayload)).toEqual({\n      input: 'Hola',\n      history: [],\n      lang: 'es',\n      userId: 'u1',\n      companyId: 'c1',\n      chatId: 'session-1',\n      messageId: 'msg-1',\n      agentName: 'MAIA',\n      agentId: 'agent-1',\n    })\n  })\n\n  it('buildAskMaiaStreamRequest includes optional fields when present', () => {\n    const request = buildAskMaiaStreamRequest({\n      ...baseAskPayload,\n      firstName: 'Ana',\n      lastName: 'Lopez',\n      feeId: 9,\n      projectId: 42,\n      attachments: [{ id: 'a1', name: 'doc.pdf' } as never],\n      projectName: 'Proyecto',\n      clientName: 'Cliente',\n      taskId: 7,\n      taskName: 'Tarea',\n      faqId: 'faq-1',\n      agentSuggestionId: 'sug-1',\n      fuaId: 'fua-1',\n      scId: 'sc-1',\n      agentEntity: 'global',\n      agentType: 'custom',\n      contextMessage: { type: 'task', id: '1', label: 'Task' },\n      contextData: { foo: 'bar' },\n      isWebSearchActive: true,\n      isDeepSearchActive: true,\n      isAutoApproveActive: true,\n    })\n\n    expect(request).toMatchObject({\n      firstName: 'Ana',\n      lastName: 'Lopez',\n      feeId: 9,\n      projectId: 42,\n      taskId: 7,\n      faqId: 'faq-1',\n      contextData: { foo: 'bar' },\n      isAutoApproveActive: true,\n    })\n  })\n\n  it('buildAskMaiaActivityOptions reflects attachment count', () => {\n    expect(buildAskMaiaActivityOptions(baseAskPayload)).toEqual({\n      isWebSearchActive: undefined,\n      isDeepSearchActive: undefined,\n      hasAttachments: false,\n      attachmentsCount: 0,\n    })\n\n    expect(\n      buildAskMaiaActivityOptions({\n        ...baseAskPayload,\n        attachments: [{ id: 'a1' } as never, { id: 'a2' } as never],\n        isWebSearchActive: true,\n      })\n    ).toEqual({\n      isWebSearchActive: true,\n      isDeepSearchActive: undefined,\n      hasAttachments: true,\n      attachmentsCount: 2,\n    })\n  })\n\n  it('buildRetryStreamRequest includes optional retry fields', () => {\n    expect(\n      buildRetryStreamRequest({\n        chatId: 'session-1',\n        messageId: 'msg-2',\n        memorySessionId: 'mem-1',\n        lang: 'es',\n        agentId: 'agent-1',\n        agentName: 'MAIA',\n      })\n    ).toEqual({\n      sessionId: 'session-1',\n      memorySessionId: 'mem-1',\n      agentId: 'agent-1',\n      lang: 'es',\n    })\n\n    expect(\n      buildRetryStreamRequest({\n        chatId: 'session-1',\n        messageId: 'msg-2',\n        memorySessionId: 'mem-1',\n        lang: 'es',\n        agentId: 'agent-1',\n        agentName: 'MAIA',\n        projectId: 42,\n        clientId: 5,\n        taskId: 9,\n        agentType: 'custom',\n        contextData: { foo: 'bar' },\n        isWebSearchActive: true,\n        isDeepSearchActive: true,\n      })\n    ).toMatchObject({\n      projectId: 42,\n      clientId: 5,\n      taskId: 9,\n      agentType: 'custom',\n      contextData: { foo: 'bar' },\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}