@projectcor/maia-components 2.44.4 → 2.44.5-1

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.spec.js

@@ -0,0 +1,192 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { sessionStreamManager } from '../../store/sessions/sessionStreamManager';
+import { useSessionsStore } from '../../store/sessions/useSessionsStore';
+import { useOrchestratorStream } from './useOrchestratorStream';
+jest.mock('../../store/sessions/sessionStreamManager', function () {
+  return {
+    sessionStreamManager: {
+      startStream: jest.fn().mockResolvedValue({
+        started: true
+      }),
+      startRetryStream: jest.fn().mockResolvedValue({
+        started: true
+      }),
+      stopStream: jest.fn(),
+      abortSilently: jest.fn()
+    }
+  };
+});
+var startStreamMock = sessionStreamManager.startStream;
+var startRetryStreamMock = sessionStreamManager.startRetryStream;
+var stopStreamMock = sessionStreamManager.stopStream;
+var abortSilentlyMock = sessionStreamManager.abortSilently;
+describe('useOrchestratorStream', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    useSessionsStore.setState({
+      meta: {},
+      messages: {},
+      viewCache: {}
+    });
+  });
+  it('delegates askMaia to sessionStreamManager.startStream', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var onFinishStream, _renderHook, result, callbacks;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onFinishStream = jest.fn();
+          _renderHook = renderHook(function () {
+            return useOrchestratorStream({
+              activeSessionId: 'session-1',
+              onFinishStream: onFinishStream
+            });
+          }), result = _renderHook.result;
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.askMaia({
+                    message: 'Hola',
+                    history: [],
+                    projectId: 42,
+                    lang: 'es',
+                    userId: 'u1',
+                    companyId: 'c1',
+                    chatId: 'session-1',
+                    messageId: 'msg-1',
+                    agentName: 'MAIA',
+                    agentId: 'agent-1',
+                    isWebSearchActive: true
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(startStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            placeholderId: 'answer-msg-1-streaming',
+            request: expect.objectContaining({
+              input: 'Hola',
+              chatId: 'session-1',
+              projectId: 42,
+              isWebSearchActive: true
+            }),
+            activityOptions: expect.objectContaining({
+              isWebSearchActive: true,
+              hasAttachments: false
+            })
+          }));
+          callbacks = startStreamMock.mock.calls[0][0].callbacks;
+          callbacks.onFinishStream({
+            content: 'Respuesta',
+            sources: null,
+            memorySessionId: 'mem-1',
+            attachments: null,
+            suggestions: ['Siguiente'],
+            completedAgentId: null,
+            resolvedContext: null,
+            reasoning: null
+          });
+          expect(onFinishStream).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            messageId: 'msg-1'
+          }), 'Respuesta', null, 'mem-1', null, ['Siguiente'], null, null, null);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('delegates retryCompletion to sessionStreamManager.startRetryStream', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useOrchestratorStream({
+              activeSessionId: 'session-1'
+            });
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.retryCompletion({
+                    chatId: 'session-1',
+                    messageId: 'msg-2',
+                    memorySessionId: 'mem-1',
+                    lang: 'es',
+                    agentId: 'agent-1',
+                    agentName: 'MAIA'
+                  });
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(startRetryStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            placeholderId: 'answer-msg-2-streaming',
+            retryRequest: expect.objectContaining({
+              sessionId: 'session-1',
+              memorySessionId: 'mem-1',
+              agentId: 'agent-1'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('stopStreaming and abortStreamSilently forward to the manager', function () {
+    var onStop = jest.fn();
+    var _renderHook3 = renderHook(function () {
+        return useOrchestratorStream({
+          activeSessionId: 'session-1',
+          onStop: onStop
+        });
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current.stopStreaming();
+      result.current.abortStreamSilently();
+    });
+    expect(stopStreamMock).toHaveBeenCalledWith('session-1', expect.objectContaining({
+      onStop: expect.any(Function)
+    }));
+    expect(abortSilentlyMock).toHaveBeenCalledWith('session-1');
+  });
+  it('updateStreamActivity patches the active session meta', function () {
+    var _useSessionsStore$get;
+    useSessionsStore.getState().ensureSession('session-1');
+    var _renderHook4 = renderHook(function () {
+        return useOrchestratorStream({
+          activeSessionId: 'session-1'
+        });
+      }),
+      result = _renderHook4.result;
+    act(function () {
+      result.current.updateStreamActivity({
+        phase: 'search',
+        message: 'Buscando'
+      });
+    });
+    expect((_useSessionsStore$get = useSessionsStore.getState().getMeta('session-1')) === null || _useSessionsStore$get === void 0 ? void 0 : _useSessionsStore$get.streamActivity).toEqual({
+      phase: 'search',
+      message: 'Buscando'
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","sessionStreamManager","useSessionsStore","useOrchestratorStream","jest","mock","startStream","fn","mockResolvedValue","started","startRetryStream","stopStream","abortSilently","startStreamMock","startRetryStreamMock","stopStreamMock","abortSilentlyMock","describe","beforeEach","clearAllMocks","setState","meta","messages","viewCache","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","onFinishStream","_renderHook","result","callbacks","wrap","_context2","prev","next","activeSessionId","_callee","_context","current","askMaia","message","history","projectId","lang","userId","companyId","chatId","messageId","agentName","agentId","isWebSearchActive","stop","expect","toHaveBeenCalledWith","objectContaining","sessionId","placeholderId","request","input","activityOptions","hasAttachments","calls","content","sources","memorySessionId","attachments","suggestions","completedAgentId","resolvedContext","reasoning","_callee4","_renderHook2","_context4","_callee3","_context3","retryCompletion","retryRequest","onStop","_renderHook3","stopStreaming","abortStreamSilently","any","Function","_useSessionsStore$get","getState","ensureSession","_renderHook4","updateStreamActivity","phase","getMeta","streamActivity","toEqual"],"sources":["../../../src/hooks/useOrchestratorStream/useOrchestratorStream.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { sessionStreamManager } from '../../store/sessions/sessionStreamManager'\nimport { useSessionsStore } from '../../store/sessions/useSessionsStore'\nimport { useOrchestratorStream } from './useOrchestratorStream'\n\njest.mock('../../store/sessions/sessionStreamManager', () => ({\n  sessionStreamManager: {\n    startStream: jest.fn().mockResolvedValue({ started: true }),\n    startRetryStream: jest.fn().mockResolvedValue({ started: true }),\n    stopStream: jest.fn(),\n    abortSilently: jest.fn(),\n  },\n}))\n\nconst startStreamMock = sessionStreamManager.startStream as jest.Mock\nconst startRetryStreamMock = sessionStreamManager.startRetryStream as jest.Mock\nconst stopStreamMock = sessionStreamManager.stopStream as jest.Mock\nconst abortSilentlyMock = sessionStreamManager.abortSilently as jest.Mock\n\ndescribe('useOrchestratorStream', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    useSessionsStore.setState({ meta: {}, messages: {}, viewCache: {} })\n  })\n\n  it('delegates askMaia to sessionStreamManager.startStream', async () => {\n    const onFinishStream = jest.fn()\n    const { result } = renderHook(() =>\n      useOrchestratorStream({\n        activeSessionId: 'session-1',\n        onFinishStream,\n      })\n    )\n\n    await act(async () => {\n      await result.current.askMaia({\n        message: 'Hola',\n        history: [],\n        projectId: 42,\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        isWebSearchActive: true,\n      })\n    })\n\n    expect(startStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        sessionId: 'session-1',\n        placeholderId: 'answer-msg-1-streaming',\n        request: expect.objectContaining({\n          input: 'Hola',\n          chatId: 'session-1',\n          projectId: 42,\n          isWebSearchActive: true,\n        }),\n        activityOptions: expect.objectContaining({\n          isWebSearchActive: true,\n          hasAttachments: false,\n        }),\n      })\n    )\n\n    const { callbacks } = startStreamMock.mock.calls[0][0]\n    callbacks.onFinishStream({\n      content: 'Respuesta',\n      sources: null,\n      memorySessionId: 'mem-1',\n      attachments: null,\n      suggestions: ['Siguiente'],\n      completedAgentId: null,\n      resolvedContext: null,\n      reasoning: null,\n    })\n\n    expect(onFinishStream).toHaveBeenCalledWith(\n      expect.objectContaining({ sessionId: 'session-1', messageId: 'msg-1' }),\n      'Respuesta',\n      null,\n      'mem-1',\n      null,\n      ['Siguiente'],\n      null,\n      null,\n      null\n    )\n  })\n\n  it('delegates retryCompletion to sessionStreamManager.startRetryStream', async () => {\n    const { result } = renderHook(() => useOrchestratorStream({ activeSessionId: 'session-1' }))\n\n    await act(async () => {\n      await result.current.retryCompletion({\n        chatId: 'session-1',\n        messageId: 'msg-2',\n        memorySessionId: 'mem-1',\n        lang: 'es',\n        agentId: 'agent-1',\n        agentName: 'MAIA',\n      })\n    })\n\n    expect(startRetryStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        sessionId: 'session-1',\n        placeholderId: 'answer-msg-2-streaming',\n        retryRequest: expect.objectContaining({\n          sessionId: 'session-1',\n          memorySessionId: 'mem-1',\n          agentId: 'agent-1',\n        }),\n      })\n    )\n  })\n\n  it('stopStreaming and abortStreamSilently forward to the manager', () => {\n    const onStop = jest.fn()\n    const { result } = renderHook(() =>\n      useOrchestratorStream({\n        activeSessionId: 'session-1',\n        onStop,\n      })\n    )\n\n    act(() => {\n      result.current.stopStreaming()\n      result.current.abortStreamSilently()\n    })\n\n    expect(stopStreamMock).toHaveBeenCalledWith('session-1', expect.objectContaining({ onStop: expect.any(Function) }))\n    expect(abortSilentlyMock).toHaveBeenCalledWith('session-1')\n  })\n\n  it('updateStreamActivity patches the active session meta', () => {\n    useSessionsStore.getState().ensureSession('session-1')\n\n    const { result } = renderHook(() => useOrchestratorStream({ activeSessionId: 'session-1' }))\n\n    act(() => {\n      result.current.updateStreamActivity({ phase: 'search', message: 'Buscando' })\n    })\n\n    expect(useSessionsStore.getState().getMeta('session-1')?.streamActivity).toEqual({\n      phase: 'search',\n      message: 'Buscando',\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useProjectSearch.helpers.js

@@ -0,0 +1,61 @@
+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; }
+export var TYPE_PROJECT = {
+  project: 'true',
+  archived: 'all'
+};
+export var buildProjectSearchFilters = function buildProjectSearchFilters() {
+  return JSON.stringify(TYPE_PROJECT);
+};
+export var mapperProjectsSearch = function mapperProjectsSearch(values) {
+  return values === null || values === void 0 ? void 0 : values.map(function (value) {
+    var _value$clientId, _value$feeId;
+    return {
+      id: value.id,
+      title: value.title,
+      clientName: value.clientName,
+      productName: value.productName,
+      brandName: value.brandName,
+      incomeType: '',
+      clientId: (_value$clientId = value.clientId) !== null && _value$clientId !== void 0 ? _value$clientId : null,
+      feeId: (_value$feeId = value.feeId) !== null && _value$feeId !== void 0 ? _value$feeId : null
+    };
+  });
+};
+export var resolveProjectTitleHighlight = function resolveProjectTitleHighlight(projectName, searchValue) {
+  if (!searchValue || !projectName.toLocaleLowerCase().includes(searchValue.toLocaleLowerCase())) {
+    return undefined;
+  }
+  var textIndex = projectName.toLowerCase().indexOf(searchValue.toLowerCase());
+  return {
+    start: textIndex,
+    length: searchValue.length
+  };
+};
+export var mapGraphqlProjectsToSetters = function mapGraphqlProjectsToSetters(projects, searchValue) {
+  return projects.map(function (project) {
+    var _project$clientName;
+    var projectName = project.title || '';
+    var titleHighlight = resolveProjectTitleHighlight(projectName, searchValue);
+    return _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+      id: project.id,
+      name: project.title,
+      title: projectName
+    }, titleHighlight && {
+      titleHighlight: titleHighlight
+    }), project.clientId != null ? {
+      clientId: project.clientId
+    } : {}), project.feeId != null ? {
+      feeId: project.feeId
+    } : {}), {}, {
+      client: {
+        name: (_project$clientName = project.clientName) !== null && _project$clientName !== void 0 ? _project$clientName : null
+      },
+      productName: project.productName || '',
+      brandName: project.brandName || '',
+      incomeType: project.incomeType || ''
+    });
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,70 @@
+import { buildProjectSearchFilters, mapGraphqlProjectsToSetters, mapperProjectsSearch, resolveProjectTitleHighlight } from './useProjectSearch.helpers';
+describe('useProjectSearch.helpers', function () {
+  describe('mapperProjectsSearch', function () {
+    it('maps GraphQL search rows into project graph objects', function () {
+      expect(mapperProjectsSearch([{
+        id: 5,
+        title: 'Landing',
+        type: 'project',
+        clientId: 1,
+        feeId: 2,
+        clientName: 'Acme',
+        brandName: 'Brand',
+        productName: 'Product',
+        projectName: 'Landing',
+        status: 'active',
+        deadline: '',
+        datetime: '',
+        archived: false,
+        __typename: 'SearchResult'
+      }])).toEqual([{
+        id: 5,
+        title: 'Landing',
+        clientName: 'Acme',
+        productName: 'Product',
+        brandName: 'Brand',
+        incomeType: '',
+        clientId: 1,
+        feeId: 2
+      }]);
+    });
+  });
+  describe('resolveProjectTitleHighlight', function () {
+    it('returns a highlight range for matching titles', function () {
+      expect(resolveProjectTitleHighlight('Landing page', 'page')).toEqual({
+        start: 8,
+        length: 4
+      });
+    });
+  });
+  describe('mapGraphqlProjectsToSetters', function () {
+    it('maps projects with optional highlight metadata', function () {
+      expect(mapGraphqlProjectsToSetters([{
+        id: 5,
+        title: 'Landing page',
+        clientName: 'Acme',
+        clientId: 1,
+        feeId: 2
+      }], 'page')).toEqual([expect.objectContaining({
+        id: 5,
+        title: 'Landing page',
+        titleHighlight: {
+          start: 8,
+          length: 4
+        },
+        client: {
+          name: 'Acme'
+        }
+      })]);
+    });
+  });
+  describe('buildProjectSearchFilters', function () {
+    it('serializes the archived project filter', function () {
+      expect(JSON.parse(buildProjectSearchFilters())).toEqual({
+        project: 'true',
+        archived: 'all'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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