@projectcor/maia-components 2.50.0-beta.1 → 2.50.1-0

package/lib/hooks/useProjectSummaryConfig.spec.js

@@ -0,0 +1,133 @@
+import { act, renderHook } from '@testing-library/react';
+import { useProjectSummaryConfig } from './useProjectSummaryConfig';
+jest.mock('./useT', function () {
+  return {
+    useTWithSection: function useTWithSection() {
+      return function (key) {
+        return key;
+      };
+    }
+  };
+});
+jest.mock('../context/cor-user', function () {
+  return {
+    CORUserRole: {
+      CLIENT: 6,
+      FREELANCER: 5,
+      PROJECT_MANAGER: 3
+    },
+    useUser: function useUser() {
+      return {
+        id: 7,
+        role_id: 3
+      };
+    }
+  };
+});
+jest.mock('../utils/autoApproveStorage', function () {
+  return {
+    readAutoApprove: function readAutoApprove() {
+      return false;
+    },
+    writeAutoApprove: jest.fn()
+  };
+});
+var project = {
+  id: 42,
+  name: 'Alpha',
+  clientId: 5,
+  client: {
+    id: 5,
+    name: 'Acme'
+  }
+};
+var task = {
+  id: 99,
+  name: 'Bugfix',
+  clientId: 5,
+  projectId: 42
+};
+describe('useProjectSummaryConfig', function () {
+  it('initializes chips project for project sections', function () {
+    var _renderHook = renderHook(function () {
+        return useProjectSummaryConfig({
+          section: 'project',
+          project: project,
+          setProject: jest.fn()
+        });
+      }),
+      result = _renderHook.result;
+    expect(result.current.context.chipsProject).toEqual({
+      projectId: '42',
+      projectName: 'Alpha',
+      clientName: 'Acme'
+    });
+  });
+  it('resolves pinned context from the most specific entity', function () {
+    var _renderHook2 = renderHook(function () {
+        return useProjectSummaryConfig({
+          section: 'task',
+          entity: {
+            projectId: '42',
+            clientId: '5'
+          },
+          project: project,
+          setProject: jest.fn(),
+          task: task
+        });
+      }),
+      result = _renderHook2.result;
+    expect(result.current.context.pinnedContext).toEqual({
+      type: 'task',
+      id: 99,
+      name: 'Bugfix',
+      parents: {
+        clientId: 5,
+        projectId: 42
+      }
+    });
+  });
+  it('selects and clears the active agent', function () {
+    var agent = {
+      id: 'agent-1',
+      name: 'Support',
+      type: 'custom'
+    };
+    var _renderHook3 = renderHook(function () {
+        return useProjectSummaryConfig({
+          section: 'header',
+          project: null,
+          setProject: jest.fn()
+        });
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current.context.selectAgent(agent);
+    });
+    expect(result.current.context.agent).toEqual(agent);
+    act(function () {
+      result.current.context.clearAgent();
+    });
+    expect(result.current.context.agent).toBeNull();
+  });
+  it('toggles web and deep search flags', function () {
+    var _renderHook4 = renderHook(function () {
+        return useProjectSummaryConfig({
+          section: 'header',
+          project: null,
+          setProject: jest.fn()
+        });
+      }),
+      result = _renderHook4.result;
+    expect(result.current.context.isWebSearchActive).toBe(false);
+    act(function () {
+      result.current.context.toggleWebSearch();
+    });
+    expect(result.current.context.isWebSearchActive).toBe(true);
+    act(function () {
+      result.current.context.toggleDeepSearch();
+    });
+    expect(result.current.context.isDeepSearchActive).toBe(true);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","useProjectSummaryConfig","jest","mock","useTWithSection","key","CORUserRole","CLIENT","FREELANCER","PROJECT_MANAGER","useUser","id","role_id","readAutoApprove","writeAutoApprove","fn","project","name","clientId","client","task","projectId","describe","it","_renderHook","section","setProject","result","expect","current","context","chipsProject","toEqual","projectName","clientName","_renderHook2","entity","pinnedContext","type","parents","agent","_renderHook3","selectAgent","clearAgent","toBeNull","_renderHook4","isWebSearchActive","toBe","toggleWebSearch","toggleDeepSearch","isDeepSearchActive"],"sources":["../../src/hooks/useProjectSummaryConfig.spec.tsx"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport type { Agent } from '../types/agent'\nimport { useProjectSummaryConfig } from './useProjectSummaryConfig'\n\njest.mock('./useT', () => ({\n  useTWithSection: () => (key: string) => key,\n}))\n\njest.mock('../context/cor-user', () => ({\n  CORUserRole: { CLIENT: 6, FREELANCER: 5, PROJECT_MANAGER: 3 },\n  useUser: () => ({ id: 7, role_id: 3 }),\n}))\n\njest.mock('../utils/autoApproveStorage', () => ({\n  readAutoApprove: () => false,\n  writeAutoApprove: jest.fn(),\n}))\n\nconst project = {\n  id: 42,\n  name: 'Alpha',\n  clientId: 5,\n  client: { id: 5, name: 'Acme' },\n}\n\nconst task = {\n  id: 99,\n  name: 'Bugfix',\n  clientId: 5,\n  projectId: 42,\n}\n\ndescribe('useProjectSummaryConfig', () => {\n  it('initializes chips project for project sections', () => {\n    const { result } = renderHook(() =>\n      useProjectSummaryConfig({\n        section: 'project',\n        project,\n        setProject: jest.fn(),\n      })\n    )\n\n    expect(result.current.context.chipsProject).toEqual({\n      projectId: '42',\n      projectName: 'Alpha',\n      clientName: 'Acme',\n    })\n  })\n\n  it('resolves pinned context from the most specific entity', () => {\n    const { result } = renderHook(() =>\n      useProjectSummaryConfig({\n        section: 'task',\n        entity: { projectId: '42', clientId: '5' },\n        project,\n        setProject: jest.fn(),\n        task,\n      })\n    )\n\n    expect(result.current.context.pinnedContext).toEqual({\n      type: 'task',\n      id: 99,\n      name: 'Bugfix',\n      parents: { clientId: 5, projectId: 42 },\n    })\n  })\n\n  it('selects and clears the active agent', () => {\n    const agent: Agent = { id: 'agent-1', name: 'Support', type: 'custom' }\n    const { result } = renderHook(() =>\n      useProjectSummaryConfig({\n        section: 'header',\n        project: null,\n        setProject: jest.fn(),\n      })\n    )\n\n    act(() => {\n      result.current.context.selectAgent(agent)\n    })\n\n    expect(result.current.context.agent).toEqual(agent)\n\n    act(() => {\n      result.current.context.clearAgent()\n    })\n\n    expect(result.current.context.agent).toBeNull()\n  })\n\n  it('toggles web and deep search flags', () => {\n    const { result } = renderHook(() =>\n      useProjectSummaryConfig({\n        section: 'header',\n        project: null,\n        setProject: jest.fn(),\n      })\n    )\n\n    expect(result.current.context.isWebSearchActive).toBe(false)\n\n    act(() => {\n      result.current.context.toggleWebSearch()\n    })\n\n    expect(result.current.context.isWebSearchActive).toBe(true)\n\n    act(() => {\n      result.current.context.toggleDeepSearch()\n    })\n\n    expect(result.current.context.isDeepSearchActive).toBe(true)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useReasoningTrace/reasoningStore.spec.js

@@ -0,0 +1,112 @@
+import { reasoningStore } from './reasoningStore';
+describe('reasoningStore', function () {
+  beforeEach(function () {
+    reasoningStore.clear();
+  });
+  it('starts streaming with an empty snapshot', function () {
+    reasoningStore.start('msg-1');
+    expect(reasoningStore.getSnapshot('msg-1')).toMatchObject({
+      id: 'msg-1',
+      steps: [],
+      phase: 'streaming'
+    });
+  });
+  it('appends thinking deltas for the same index', function () {
+    reasoningStore.start('msg-1');
+    reasoningStore.appendThinking('msg-1', 0, 'Pens');
+    reasoningStore.appendThinking('msg-1', 0, 'ando');
+    expect(reasoningStore.getSnapshot('msg-1').steps).toEqual([expect.objectContaining({
+      i: 0,
+      type: 'thinking',
+      text: 'Pensando'
+    })]);
+  });
+  it('applies reasoning steps and upserts by index', function () {
+    reasoningStore.start('msg-1');
+    reasoningStore.applyStep('msg-1', {
+      i: 1,
+      type: 'action',
+      tool: 'search_web',
+      status: 'running'
+    });
+    reasoningStore.applyStep('msg-1', {
+      i: 1,
+      type: 'action',
+      tool: 'search_web',
+      status: 'ok'
+    });
+    var _reasoningStore$getSn = reasoningStore.getSnapshot('msg-1'),
+      steps = _reasoningStore$getSn.steps;
+    expect(steps).toHaveLength(1);
+    expect(steps[0]).toMatchObject({
+      i: 1,
+      status: 'ok'
+    });
+  });
+  it('finishes with authoritative trace payload when provided', function () {
+    reasoningStore.start('msg-1');
+    reasoningStore.finish('msg-1', {
+      steps: [{
+        i: 0,
+        type: 'thinking',
+        text: 'Listo'
+      }],
+      summary: {
+        stepCount: 1,
+        toolCount: 0
+      }
+    });
+    var snapshot = reasoningStore.getSnapshot('msg-1');
+    expect(snapshot.phase).toBe('done');
+    expect(snapshot.summary).toEqual(expect.objectContaining({
+      toolCount: 0
+    }));
+    expect(snapshot.steps).toEqual([expect.objectContaining({
+      type: 'thinking',
+      text: 'Listo'
+    })]);
+  });
+  it('clears running steps on finish without authoritative payload', function () {
+    reasoningStore.start('msg-1');
+    reasoningStore.applyStep('msg-1', {
+      i: 1,
+      type: 'action',
+      tool: 'create_task',
+      status: 'running'
+    });
+    reasoningStore.finish('msg-1', null);
+    expect(reasoningStore.getSnapshot('msg-1').steps[0].status).toBe('ok');
+    expect(reasoningStore.getSnapshot('msg-1').phase).toBe('done');
+  });
+  it('renames snapshots and handoff flags', function () {
+    reasoningStore.start('temp-id');
+    reasoningStore.applyStep('temp-id', {
+      i: 0,
+      type: 'narration',
+      text: 'Intro'
+    });
+    reasoningStore.rename('temp-id', 'final-id');
+    expect(reasoningStore.getSnapshot('temp-id').steps).toHaveLength(0);
+    expect(reasoningStore.getSnapshot('final-id').id).toBe('final-id');
+    expect(reasoningStore.isNarrationHandoffPending('final-id')).toBe(true);
+  });
+  it('notifies subscribers on mutations', function () {
+    var listener = jest.fn();
+    var unsubscribe = reasoningStore.subscribe(listener);
+    reasoningStore.start('msg-1');
+    expect(listener).toHaveBeenCalled();
+    unsubscribe();
+    listener.mockClear();
+    reasoningStore.appendThinking('msg-1', 0, 'x');
+    expect(listener).not.toHaveBeenCalled();
+  });
+  it('remove and clear drop snapshots', function () {
+    reasoningStore.start('msg-1');
+    reasoningStore.remove('msg-1');
+    expect(reasoningStore.getSnapshot('msg-1').phase).toBe('idle');
+    reasoningStore.start('msg-2');
+    reasoningStore.clear();
+    expect(reasoningStore.getSnapshot('msg-2').phase).toBe('idle');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["reasoningStore","describe","beforeEach","clear","it","start","expect","getSnapshot","toMatchObject","id","steps","phase","appendThinking","toEqual","objectContaining","i","type","text","applyStep","tool","status","_reasoningStore$getSn","toHaveLength","finish","summary","stepCount","toolCount","snapshot","toBe","rename","isNarrationHandoffPending","listener","jest","fn","unsubscribe","subscribe","toHaveBeenCalled","mockClear","not","remove"],"sources":["../../../src/hooks/useReasoningTrace/reasoningStore.spec.ts"],"sourcesContent":["import { reasoningStore } from './reasoningStore'\n\ndescribe('reasoningStore', () => {\n  beforeEach(() => {\n    reasoningStore.clear()\n  })\n\n  it('starts streaming with an empty snapshot', () => {\n    reasoningStore.start('msg-1')\n\n    expect(reasoningStore.getSnapshot('msg-1')).toMatchObject({\n      id: 'msg-1',\n      steps: [],\n      phase: 'streaming',\n    })\n  })\n\n  it('appends thinking deltas for the same index', () => {\n    reasoningStore.start('msg-1')\n    reasoningStore.appendThinking('msg-1', 0, 'Pens')\n    reasoningStore.appendThinking('msg-1', 0, 'ando')\n\n    expect(reasoningStore.getSnapshot('msg-1').steps).toEqual([\n      expect.objectContaining({ i: 0, type: 'thinking', text: 'Pensando' }),\n    ])\n  })\n\n  it('applies reasoning steps and upserts by index', () => {\n    reasoningStore.start('msg-1')\n    reasoningStore.applyStep('msg-1', { i: 1, type: 'action', tool: 'search_web', status: 'running' })\n    reasoningStore.applyStep('msg-1', { i: 1, type: 'action', tool: 'search_web', status: 'ok' })\n\n    const { steps } = reasoningStore.getSnapshot('msg-1')\n    expect(steps).toHaveLength(1)\n    expect(steps[0]).toMatchObject({ i: 1, status: 'ok' })\n  })\n\n  it('finishes with authoritative trace payload when provided', () => {\n    reasoningStore.start('msg-1')\n    reasoningStore.finish('msg-1', {\n      steps: [{ i: 0, type: 'thinking', text: 'Listo' }],\n      summary: { stepCount: 1, toolCount: 0 },\n    })\n\n    const snapshot = reasoningStore.getSnapshot('msg-1')\n    expect(snapshot.phase).toBe('done')\n    expect(snapshot.summary).toEqual(expect.objectContaining({ toolCount: 0 }))\n    expect(snapshot.steps).toEqual([expect.objectContaining({ type: 'thinking', text: 'Listo' })])\n  })\n\n  it('clears running steps on finish without authoritative payload', () => {\n    reasoningStore.start('msg-1')\n    reasoningStore.applyStep('msg-1', { i: 1, type: 'action', tool: 'create_task', status: 'running' })\n    reasoningStore.finish('msg-1', null)\n\n    expect(reasoningStore.getSnapshot('msg-1').steps[0].status).toBe('ok')\n    expect(reasoningStore.getSnapshot('msg-1').phase).toBe('done')\n  })\n\n  it('renames snapshots and handoff flags', () => {\n    reasoningStore.start('temp-id')\n    reasoningStore.applyStep('temp-id', { i: 0, type: 'narration', text: 'Intro' })\n    reasoningStore.rename('temp-id', 'final-id')\n\n    expect(reasoningStore.getSnapshot('temp-id').steps).toHaveLength(0)\n    expect(reasoningStore.getSnapshot('final-id').id).toBe('final-id')\n    expect(reasoningStore.isNarrationHandoffPending('final-id')).toBe(true)\n  })\n\n  it('notifies subscribers on mutations', () => {\n    const listener = jest.fn()\n    const unsubscribe = reasoningStore.subscribe(listener)\n\n    reasoningStore.start('msg-1')\n    expect(listener).toHaveBeenCalled()\n\n    unsubscribe()\n    listener.mockClear()\n    reasoningStore.appendThinking('msg-1', 0, 'x')\n    expect(listener).not.toHaveBeenCalled()\n  })\n\n  it('remove and clear drop snapshots', () => {\n    reasoningStore.start('msg-1')\n    reasoningStore.remove('msg-1')\n    expect(reasoningStore.getSnapshot('msg-1').phase).toBe('idle')\n\n    reasoningStore.start('msg-2')\n    reasoningStore.clear()\n    expect(reasoningStore.getSnapshot('msg-2').phase).toBe('idle')\n  })\n})\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,33 @@
+import { buildActiveClientSearchFilter, CLIENT_STATUS_ACTIVE, mapClientsSearchResults } from './useRecentClientsSearch.helpers';
+describe('useRecentClientsSearch.helpers', function () {
+  describe('buildActiveClientSearchFilter', function () {
+    it('returns empty filter without query', function () {
+      expect(buildActiveClientSearchFilter('')).toEqual({});
+    });
+    it('filters active clients by name', function () {
+      expect(buildActiveClientSearchFilter('acme')).toEqual({
+        name: 'acme',
+        clientStatusId: [CLIENT_STATUS_ACTIVE]
+      });
+    });
+  });
+  describe('mapClientsSearchResults', function () {
+    it('highlights matching substrings case-insensitively', function () {
+      expect(mapClientsSearchResults([{
+        id: '1',
+        name: 'Acme Corp'
+      }], 'corp')).toEqual([{
+        id: '1',
+        name: 'Acme Corp',
+        nameHighlight: {
+          start: 5,
+          length: 4
+        }
+      }]);
+    });
+    it('returns an empty list for null payloads', function () {
+      expect(mapClientsSearchResults(null, 'x')).toEqual([]);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useRecentClientsSearch.spec.js

@@ -0,0 +1,85 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable import/first -- jest mocks must hoist before module under test */
+import { act, renderHook, waitFor } from '@testing-library/react';
+jest.mock('../services/query', function () {
+  return {
+    SEARCH_CLIENTS: {}
+  };
+});
+jest.mock('./useDebounce', function () {
+  return {
+    useDebounce: function useDebounce(value) {
+      return value;
+    }
+  };
+});
+var queryState = {
+  loading: false
+};
+var fetchSearchClients = jest.fn();
+jest.mock('@apollo/client', function () {
+  return {
+    useLazyQuery: function useLazyQuery() {
+      return [fetchSearchClients, queryState];
+    }
+  };
+});
+import { useRecentClientsSearch } from './useRecentClientsSearch';
+describe('useRecentClientsSearch', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    queryState.data = undefined;
+    queryState.loading = false;
+    queryState.error = undefined;
+  });
+  it('maps GraphQL client search results with highlights', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _renderHook, result, rerender;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useRecentClientsSearch();
+          }), result = _renderHook.result, rerender = _renderHook.rerender;
+          act(function () {
+            result.current.updateSearchValue('acme');
+          });
+          queryState.data = {
+            clients: {
+              data: [{
+                id: '1',
+                name: 'Acme Corp',
+                totalProyectos: 2
+              }]
+            }
+          };
+          rerender();
+          _context.next = 1;
+          return waitFor(function () {
+            expect(result.current.recentClients).toEqual([{
+              id: '1',
+              name: 'Acme Corp',
+              nameHighlight: {
+                start: 0,
+                length: 4
+              },
+              totalProyectos: 2
+            }]);
+          });
+        case 1:
+          expect(fetchSearchClients).toHaveBeenCalledWith(expect.objectContaining({
+            variables: expect.objectContaining({
+              filter: {
+                name: 'acme',
+                clientStatusId: [1]
+              }
+            })
+          }));
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useRecentContexts.spec.js

@@ -0,0 +1,139 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { getRecentContexts } from '../services/maia/RecentContexts';
+import { useRecentContexts } from './useRecentContexts';
+jest.mock('../services/maia/RecentContexts', function () {
+  return {
+    getRecentContexts: jest.fn()
+  };
+});
+var getRecentContextsMock = getRecentContexts;
+var sampleContexts = [{
+  type: 'project',
+  id: 'p1',
+  name: 'Alpha'
+}];
+describe('useRecentContexts', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    getRecentContextsMock.mockResolvedValue(sampleContexts);
+  });
+  it('loads recent contexts on mount', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useRecentContexts({
+              agentId: 'agent-1',
+              limit: 5
+            });
+          }), result = _renderHook.result;
+          _context.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loaded).toBe(true);
+          });
+        case 1:
+          expect(getRecentContextsMock).toHaveBeenCalledWith({
+            agentId: 'agent-1',
+            limit: 5
+          });
+          expect(result.current.contexts).toEqual(sampleContexts);
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('clears state when disabled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useRecentContexts({
+              enabled: false
+            });
+          }), result = _renderHook2.result;
+          _context2.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loading).toBe(false);
+          });
+        case 1:
+          expect(getRecentContextsMock).not.toHaveBeenCalled();
+          expect(result.current.contexts).toEqual([]);
+          expect(result.current.loaded).toBe(false);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('stores an error message when the service fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          getRecentContextsMock.mockRejectedValue(new Error('Service unavailable'));
+          _renderHook3 = renderHook(function () {
+            return useRecentContexts({
+              agentId: 'agent-2'
+            });
+          }), result = _renderHook3.result;
+          _context3.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loaded).toBe(true);
+          });
+        case 1:
+          expect(result.current.error).toBe('Service unavailable');
+          expect(result.current.contexts).toEqual([]);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('supports manual refetch', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _renderHook4 = renderHook(function () {
+            return useRecentContexts({
+              agentId: 'agent-3'
+            });
+          }), result = _renderHook4.result;
+          _context5.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loaded).toBe(true);
+          });
+        case 1:
+          getRecentContextsMock.mockClear();
+          _context5.next = 2;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+            return _regeneratorRuntime.wrap(function (_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  _context4.next = 1;
+                  return result.current.fetchRecentContexts();
+                case 1:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          })));
+        case 2:
+          expect(getRecentContextsMock).toHaveBeenCalledWith({
+            agentId: 'agent-3',
+            limit: 9
+          });
+        case 3:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","waitFor","getRecentContexts","useRecentContexts","jest","mock","fn","getRecentContextsMock","sampleContexts","type","id","name","describe","beforeEach","clearAllMocks","mockResolvedValue","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_renderHook","result","wrap","_context","prev","next","agentId","limit","expect","current","loaded","toBe","toHaveBeenCalledWith","contexts","toEqual","error","toBeNull","stop","_callee2","_renderHook2","_context2","enabled","loading","not","toHaveBeenCalled","_callee3","_renderHook3","_context3","mockRejectedValue","Error","_callee5","_renderHook4","_context5","mockClear","_callee4","_context4","fetchRecentContexts"],"sources":["../../src/hooks/useRecentContexts.spec.ts"],"sourcesContent":["import { act, renderHook, waitFor } from '@testing-library/react'\nimport { getRecentContexts } from '../services/maia/RecentContexts'\nimport { useRecentContexts } from './useRecentContexts'\n\njest.mock('../services/maia/RecentContexts', () => ({\n  getRecentContexts: jest.fn(),\n}))\n\nconst getRecentContextsMock = getRecentContexts as jest.MockedFunction<typeof getRecentContexts>\n\nconst sampleContexts = [{ type: 'project' as const, id: 'p1', name: 'Alpha' }]\n\ndescribe('useRecentContexts', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    getRecentContextsMock.mockResolvedValue(sampleContexts)\n  })\n\n  it('loads recent contexts on mount', async () => {\n    const { result } = renderHook(() => useRecentContexts({ agentId: 'agent-1', limit: 5 }))\n\n    await waitFor(() => expect(result.current.loaded).toBe(true))\n\n    expect(getRecentContextsMock).toHaveBeenCalledWith({ agentId: 'agent-1', limit: 5 })\n    expect(result.current.contexts).toEqual(sampleContexts)\n    expect(result.current.error).toBeNull()\n  })\n\n  it('clears state when disabled', async () => {\n    const { result } = renderHook(() => useRecentContexts({ enabled: false }))\n\n    await waitFor(() => expect(result.current.loading).toBe(false))\n\n    expect(getRecentContextsMock).not.toHaveBeenCalled()\n    expect(result.current.contexts).toEqual([])\n    expect(result.current.loaded).toBe(false)\n  })\n\n  it('stores an error message when the service fails', async () => {\n    getRecentContextsMock.mockRejectedValue(new Error('Service unavailable'))\n    const { result } = renderHook(() => useRecentContexts({ agentId: 'agent-2' }))\n\n    await waitFor(() => expect(result.current.loaded).toBe(true))\n\n    expect(result.current.error).toBe('Service unavailable')\n    expect(result.current.contexts).toEqual([])\n  })\n\n  it('supports manual refetch', async () => {\n    const { result } = renderHook(() => useRecentContexts({ agentId: 'agent-3' }))\n\n    await waitFor(() => expect(result.current.loaded).toBe(true))\n    getRecentContextsMock.mockClear()\n\n    await act(async () => {\n      await result.current.fetchRecentContexts()\n    })\n\n    expect(getRecentContextsMock).toHaveBeenCalledWith({ agentId: 'agent-3', limit: 9 })\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useResize.spec.js

@@ -0,0 +1,37 @@
+import { renderHook } from '@testing-library/react';
+import { createRef } from 'react';
+import { useResizeListener } from './useResize';
+describe('useResizeListener', function () {
+  var attachRef = function attachRef(scrollWidth, clientWidth) {
+    var ref = /*#__PURE__*/createRef();
+    var node = document.createElement('div');
+    Object.defineProperty(node, 'scrollWidth', {
+      value: scrollWidth
+    });
+    Object.defineProperty(node, 'clientWidth', {
+      value: clientWidth
+    });
+    Object.defineProperty(ref, 'current', {
+      value: node,
+      writable: true
+    });
+    return ref;
+  };
+  it('shows the tooltip when the text overflows', function () {
+    var ref = attachRef(200, 80);
+    var _renderHook = renderHook(function () {
+        return useResizeListener(ref, []);
+      }),
+      result = _renderHook.result;
+    expect(result.current.showTooltip).toBe(true);
+  });
+  it('hides the tooltip when the text fits', function () {
+    var ref = attachRef(80, 200);
+    var _renderHook2 = renderHook(function () {
+        return useResizeListener(ref, []);
+      }),
+      result = _renderHook2.result;
+    expect(result.current.showTooltip).toBe(false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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