@projectcor/maia-components 2.44.3 → 2.44.5-0

package/lib/components/atoms/ContextMentionItem/ContextMentionItem.spec.js

@@ -0,0 +1,107 @@
+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 { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ContextMentionItem } from './ContextMentionItem';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../hooks/useResize', function () {
+  return {
+    useResizeListener: function useResizeListener() {
+      return {
+        showTooltip: false
+      };
+    }
+  };
+});
+var baseItem = function baseItem() {
+  var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return _objectSpread({
+    id: '1',
+    type: 'client',
+    primary: 'Acme Corp',
+    raw: {
+      id: '1',
+      name: 'Acme Corp'
+    }
+  }, overrides);
+};
+describe('ContextMentionItem', function () {
+  it('renders a user row with position fallback', function () {
+    var onSelect = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionItem, {
+      item: baseItem({
+        type: 'user',
+        primary: 'Ana',
+        raw: {
+          id: 'u1',
+          name: 'Ana García',
+          positionName: 'PM'
+        }
+      }),
+      onSelect: onSelect
+    }));
+    expect(screen.getByText('Ana')).toBeInTheDocument();
+    expect(screen.getByText('PM')).toBeInTheDocument();
+  });
+  it('renders a project row', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionItem, {
+      item: baseItem({
+        type: 'project',
+        primary: 'Alpha Project'
+      }),
+      onSelect: jest.fn()
+    }));
+    expect(screen.getByText('Alpha Project')).toBeInTheDocument();
+  });
+  it('renders a task row with project name', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionItem, {
+      item: baseItem({
+        type: 'task',
+        primary: 'Landing page',
+        raw: {
+          id: 't1',
+          name: 'Landing page',
+          projectName: 'Alpha Project'
+        }
+      }),
+      onSelect: jest.fn()
+    }));
+    expect(screen.getByText('Landing page')).toBeInTheDocument();
+    expect(screen.getByText('Alpha Project')).toBeInTheDocument();
+  });
+  it('renders client breadcrumb and calls onSelect on click', function () {
+    var onSelect = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionItem, {
+      item: baseItem({
+        breadcrumb: {
+          count: 3,
+          countLabel: 'projects',
+          parent: 'Globex'
+        }
+      }),
+      onSelect: onSelect
+    }));
+    expect(screen.getByText(/3/)).toBeInTheDocument();
+    expect(screen.getByText('Globex')).toBeInTheDocument();
+    fireEvent.mouseDown(screen.getByText('Acme Corp'));
+    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({
+      id: '1',
+      type: 'client'
+    }));
+  });
+  it('renders an MCP row', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionItem, {
+      item: baseItem({
+        type: 'mcp',
+        primary: 'Jira',
+        raw: {
+          id: 'jira',
+          name: 'Jira'
+        }
+      }),
+      onSelect: jest.fn()
+    }));
+    expect(screen.getByText('Jira')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","ContextMentionItem","jsx","_jsx","jest","mock","useResizeListener","showTooltip","baseItem","overrides","arguments","length","undefined","_objectSpread","id","type","primary","raw","name","describe","it","onSelect","fn","item","positionName","expect","getByText","toBeInTheDocument","projectName","breadcrumb","count","countLabel","parent","mouseDown","toHaveBeenCalledWith","objectContaining"],"sources":["../../../../src/components/atoms/ContextMentionItem/ContextMentionItem.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport type { ContextMentionItem as ContextMentionItemType } from '../../../types/contextMention'\nimport { ContextMentionItem } from './ContextMentionItem'\n\njest.mock('../../../hooks/useResize', () => ({\n  useResizeListener: () => ({ showTooltip: false }),\n}))\n\nconst baseItem = (overrides: Partial<ContextMentionItemType> = {}): ContextMentionItemType => ({\n  id: '1',\n  type: 'client',\n  primary: 'Acme Corp',\n  raw: { id: '1', name: 'Acme Corp' },\n  ...overrides,\n})\n\ndescribe('ContextMentionItem', () => {\n  it('renders a user row with position fallback', () => {\n    const onSelect = jest.fn()\n\n    renderWithProviders(\n      <ContextMentionItem\n        item={baseItem({\n          type: 'user',\n          primary: 'Ana',\n          raw: { id: 'u1', name: 'Ana García', positionName: 'PM' },\n        })}\n        onSelect={onSelect}\n      />\n    )\n\n    expect(screen.getByText('Ana')).toBeInTheDocument()\n    expect(screen.getByText('PM')).toBeInTheDocument()\n  })\n\n  it('renders a project row', () => {\n    renderWithProviders(\n      <ContextMentionItem item={baseItem({ type: 'project', primary: 'Alpha Project' })} onSelect={jest.fn()} />\n    )\n\n    expect(screen.getByText('Alpha Project')).toBeInTheDocument()\n  })\n\n  it('renders a task row with project name', () => {\n    renderWithProviders(\n      <ContextMentionItem\n        item={baseItem({\n          type: 'task',\n          primary: 'Landing page',\n          raw: { id: 't1', name: 'Landing page', projectName: 'Alpha Project' },\n        })}\n        onSelect={jest.fn()}\n      />\n    )\n\n    expect(screen.getByText('Landing page')).toBeInTheDocument()\n    expect(screen.getByText('Alpha Project')).toBeInTheDocument()\n  })\n\n  it('renders client breadcrumb and calls onSelect on click', () => {\n    const onSelect = jest.fn()\n\n    renderWithProviders(\n      <ContextMentionItem\n        item={baseItem({\n          breadcrumb: { count: 3, countLabel: 'projects', parent: 'Globex' },\n        })}\n        onSelect={onSelect}\n      />\n    )\n\n    expect(screen.getByText(/3/)).toBeInTheDocument()\n    expect(screen.getByText('Globex')).toBeInTheDocument()\n\n    fireEvent.mouseDown(screen.getByText('Acme Corp'))\n    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ id: '1', type: 'client' }))\n  })\n\n  it('renders an MCP row', () => {\n    renderWithProviders(\n      <ContextMentionItem\n        item={baseItem({ type: 'mcp', primary: 'Jira', raw: { id: 'jira', name: 'Jira' } })}\n        onSelect={jest.fn()}\n      />\n    )\n\n    expect(screen.getByText('Jira')).toBeInTheDocument()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/atoms/ContextMentionPopover/ContextMentionPopover.spec.js

@@ -0,0 +1,136 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+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 { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ContextMentionPopover } from './ContextMentionPopover';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../hooks/useT', function () {
+  return {
+    useT: function useT() {
+      return {
+        t: function t(_key, opts) {
+          var _opts$defaultValue;
+          return (_opts$defaultValue = opts === null || opts === void 0 ? void 0 : opts.defaultValue) !== null && _opts$defaultValue !== void 0 ? _opts$defaultValue : _key;
+        }
+      };
+    }
+  };
+});
+jest.mock('../ContextMentionItem', function () {
+  return {
+    ContextMentionItem: function ContextMentionItem(_ref) {
+      var item = _ref.item,
+        active = _ref.active,
+        onSelect = _ref.onSelect,
+        onHover = _ref.onHover;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        role: "option",
+        "aria-selected": active,
+        onMouseEnter: onHover,
+        onClick: function onClick() {
+          return onSelect(item);
+        },
+        children: item.primary
+      });
+    }
+  };
+});
+var baseItem = {
+  id: 1,
+  type: 'project',
+  primary: 'Proyecto Alpha',
+  raw: {
+    id: 1,
+    name: 'Proyecto Alpha'
+  }
+};
+var baseProps = {
+  allowedTypes: ['project', 'task'],
+  activeType: 'project',
+  onTypeChange: jest.fn(),
+  items: [baseItem],
+  loading: false,
+  error: false,
+  searchValue: '',
+  onItemSelected: jest.fn()
+};
+describe('ContextMentionPopover', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    HTMLElement.prototype.scrollIntoView = jest.fn();
+    global.ResizeObserver = /*#__PURE__*/_createClass(function _class() {
+      _classCallCheck(this, _class);
+      _defineProperty(this, "observe", jest.fn());
+      _defineProperty(this, "disconnect", jest.fn());
+      _defineProperty(this, "unobserve", jest.fn());
+    });
+  });
+  it('switches tabs and selects an item', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionPopover, _objectSpread({}, baseProps)));
+    fireEvent.mouseDown(screen.getByRole('button', {
+      name: '@@ Tarea'
+    }));
+    expect(baseProps.onTypeChange).toHaveBeenCalledWith('task');
+    fireEvent.click(screen.getByRole('option', {
+      name: 'Proyecto Alpha'
+    }));
+    expect(baseProps.onItemSelected).toHaveBeenCalledWith(baseItem);
+  });
+  it('supports pin mode search keyboard navigation', function () {
+    var onSearchChange = jest.fn();
+    var onRequestClose = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ContextMentionPopover, _objectSpread(_objectSpread({}, baseProps), {}, {
+      showSearchInput: true,
+      searchPlaceholder: "Buscar entidad",
+      searchValue: "",
+      onSearchChange: onSearchChange,
+      onRequestClose: onRequestClose,
+      items: [baseItem, {
+        id: 2,
+        type: 'project',
+        primary: 'Beta',
+        raw: {
+          id: 2,
+          name: 'Beta'
+        }
+      }]
+    })));
+    var input = screen.getByPlaceholderText('Buscar entidad');
+    fireEvent.keyDown(input, {
+      key: 'ArrowDown'
+    });
+    fireEvent.keyDown(input, {
+      key: 'Enter'
+    });
+    expect(baseProps.onItemSelected).toHaveBeenCalledWith({
+      id: 2,
+      type: 'project',
+      primary: 'Beta',
+      raw: {
+        id: 2,
+        name: 'Beta'
+      }
+    });
+    fireEvent.keyDown(input, {
+      key: 'Escape'
+    });
+    expect(onRequestClose).toHaveBeenCalled();
+  });
+  it('shows loading and error states', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(ContextMentionPopover, _objectSpread(_objectSpread({}, baseProps), {}, {
+        loading: true,
+        items: []
+      }))),
+      rerender = _renderWithProviders.rerender;
+    expect(screen.getByText('Buscando...')).toBeInTheDocument();
+    rerender(/*#__PURE__*/_jsx(ContextMentionPopover, _objectSpread(_objectSpread({}, baseProps), {}, {
+      error: true,
+      items: []
+    })));
+    expect(screen.getByText('Hubo un problema al buscar')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","ContextMentionPopover","jsx","_jsx","jest","mock","useT","t","_key","opts","_opts$defaultValue","defaultValue","ContextMentionItem","_ref","item","active","onSelect","onHover","type","role","onMouseEnter","onClick","children","primary","baseItem","id","raw","name","baseProps","allowedTypes","activeType","onTypeChange","fn","items","loading","error","searchValue","onItemSelected","describe","beforeEach","clearAllMocks","HTMLElement","prototype","scrollIntoView","global","ResizeObserver","_createClass","_class","_classCallCheck","_defineProperty","it","_objectSpread","mouseDown","getByRole","expect","toHaveBeenCalledWith","click","onSearchChange","onRequestClose","showSearchInput","searchPlaceholder","input","getByPlaceholderText","keyDown","key","toHaveBeenCalled","_renderWithProviders","rerender","getByText","toBeInTheDocument"],"sources":["../../../../src/components/atoms/ContextMentionPopover/ContextMentionPopover.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { ContextMentionPopover } from './ContextMentionPopover'\n\njest.mock('../../../hooks/useT', () => ({\n  useT: () => ({\n    t: (_key: string, opts?: { defaultValue?: string }) => opts?.defaultValue ?? _key,\n  }),\n}))\n\njest.mock('../ContextMentionItem', () => ({\n  ContextMentionItem: ({\n    item,\n    active,\n    onSelect,\n    onHover,\n  }: {\n    item: { primary: string }\n    active: boolean\n    onSelect: (value: unknown) => void\n    onHover: () => void\n  }) => (\n    <button type=\"button\" role=\"option\" aria-selected={active} onMouseEnter={onHover} onClick={() => onSelect(item)}>\n      {item.primary}\n    </button>\n  ),\n}))\n\nconst baseItem = {\n  id: 1,\n  type: 'project' as const,\n  primary: 'Proyecto Alpha',\n  raw: { id: 1, name: 'Proyecto Alpha' },\n}\n\nconst baseProps = {\n  allowedTypes: ['project', 'task'] as const,\n  activeType: 'project' as const,\n  onTypeChange: jest.fn(),\n  items: [baseItem],\n  loading: false,\n  error: false,\n  searchValue: '',\n  onItemSelected: jest.fn(),\n}\n\ndescribe('ContextMentionPopover', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    HTMLElement.prototype.scrollIntoView = jest.fn()\n    global.ResizeObserver = class {\n      observe = jest.fn()\n\n      disconnect = jest.fn()\n\n      unobserve = jest.fn()\n    } as unknown as typeof ResizeObserver\n  })\n\n  it('switches tabs and selects an item', () => {\n    renderWithProviders(<ContextMentionPopover {...baseProps} />)\n\n    fireEvent.mouseDown(screen.getByRole('button', { name: '@@ Tarea' }))\n    expect(baseProps.onTypeChange).toHaveBeenCalledWith('task')\n\n    fireEvent.click(screen.getByRole('option', { name: 'Proyecto Alpha' }))\n    expect(baseProps.onItemSelected).toHaveBeenCalledWith(baseItem)\n  })\n\n  it('supports pin mode search keyboard navigation', () => {\n    const onSearchChange = jest.fn()\n    const onRequestClose = jest.fn()\n\n    renderWithProviders(\n      <ContextMentionPopover\n        {...baseProps}\n        showSearchInput\n        searchPlaceholder=\"Buscar entidad\"\n        searchValue=\"\"\n        onSearchChange={onSearchChange}\n        onRequestClose={onRequestClose}\n        items={[baseItem, { id: 2, type: 'project', primary: 'Beta', raw: { id: 2, name: 'Beta' } }]}\n      />\n    )\n\n    const input = screen.getByPlaceholderText('Buscar entidad')\n    fireEvent.keyDown(input, { key: 'ArrowDown' })\n    fireEvent.keyDown(input, { key: 'Enter' })\n    expect(baseProps.onItemSelected).toHaveBeenCalledWith({\n      id: 2,\n      type: 'project',\n      primary: 'Beta',\n      raw: { id: 2, name: 'Beta' },\n    })\n\n    fireEvent.keyDown(input, { key: 'Escape' })\n    expect(onRequestClose).toHaveBeenCalled()\n  })\n\n  it('shows loading and error states', () => {\n    const { rerender } = renderWithProviders(<ContextMentionPopover {...baseProps} loading items={[]} />)\n    expect(screen.getByText('Buscando...')).toBeInTheDocument()\n\n    rerender(<ContextMentionPopover {...baseProps} error items={[]} />)\n    expect(screen.getByText('Hubo un problema al buscar')).toBeInTheDocument()\n  })\n})\n"],"mappings":";;;;;AAAA,SAASA,SAAS,EAAEC,mBAAmB,EAAEC,MAAM,QAAQ,0BAA0B;AACjF,SAASC,qBAAqB,QAAQ,yBAAyB;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAE/DC,IAAI,CAACC,IAAI,CAAC,qBAAqB,EAAE;EAAA,OAAO;IACtCC,IAAI,EAAE,SAANA,IAAIA,CAAA;MAAA,OAAS;QACXC,CAAC,EAAE,SAAHA,CAACA,CAAGC,IAAY,EAAEC,IAAgC;UAAA,IAAAC,kBAAA;UAAA,QAAAA,kBAAA,GAAKD,IAAI,aAAJA,IAAI,uBAAJA,IAAI,CAAEE,YAAY,cAAAD,kBAAA,cAAAA,kBAAA,GAAIF,IAAI;QAAA;MACnF,CAAC;IAAA;EACH,CAAC;AAAA,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,uBAAuB,EAAE;EAAA,OAAO;IACxCO,kBAAkB,EAAE,SAApBA,kBAAkBA,CAAAC,IAAA;MAAA,IAChBC,IAAI,GAAAD,IAAA,CAAJC,IAAI;QACJC,MAAM,GAAAF,IAAA,CAANE,MAAM;QACNC,QAAQ,GAAAH,IAAA,CAARG,QAAQ;QACRC,OAAO,GAAAJ,IAAA,CAAPI,OAAO;MAAA,oBAOPd,IAAA;QAAQe,IAAI,EAAC,QAAQ;QAACC,IAAI,EAAC,QAAQ;QAAC,iBAAeJ,MAAO;QAACK,YAAY,EAAEH,OAAQ;QAACI,OAAO,EAAE,SAATA,OAAOA,CAAA;UAAA,OAAQL,QAAQ,CAACF,IAAI,CAAC;QAAA,CAAC;QAAAQ,QAAA,EAC7GR,IAAI,CAACS;MAAO,CACP,CAAC;IAAA;EAEb,CAAC;AAAA,CAAC,CAAC;AAEH,IAAMC,QAAQ,GAAG;EACfC,EAAE,EAAE,CAAC;EACLP,IAAI,EAAE,SAAkB;EACxBK,OAAO,EAAE,gBAAgB;EACzBG,GAAG,EAAE;IAAED,EAAE,EAAE,CAAC;IAAEE,IAAI,EAAE;EAAiB;AACvC,CAAC;AAED,IAAMC,SAAS,GAAG;EAChBC,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,CAAU;EAC1CC,UAAU,EAAE,SAAkB;EAC9BC,YAAY,EAAE3B,IAAI,CAAC4B,EAAE,CAAC,CAAC;EACvBC,KAAK,EAAE,CAACT,QAAQ,CAAC;EACjBU,OAAO,EAAE,KAAK;EACdC,KAAK,EAAE,KAAK;EACZC,WAAW,EAAE,EAAE;EACfC,cAAc,EAAEjC,IAAI,CAAC4B,EAAE,CAAC;AAC1B,CAAC;AAEDM,QAAQ,CAAC,uBAAuB,EAAE,YAAM;EACtCC,UAAU,CAAC,YAAM;IACfnC,IAAI,CAACoC,aAAa,CAAC,CAAC;IACpBC,WAAW,CAACC,SAAS,CAACC,cAAc,GAAGvC,IAAI,CAAC4B,EAAE,CAAC,CAAC;IAChDY,MAAM,CAACC,cAAc,gBAAAC,YAAA,UAAAC,OAAA;MAAAC,eAAA,OAAAD,MAAA;MAAAE,eAAA,kBACT7C,IAAI,CAAC4B,EAAE,CAAC,CAAC;MAAAiB,eAAA,qBAEN7C,IAAI,CAAC4B,EAAE,CAAC,CAAC;MAAAiB,eAAA,oBAEV7C,IAAI,CAAC4B,EAAE,CAAC,CAAC;IAAA,EACc;EACvC,CAAC,CAAC;EAEFkB,EAAE,CAAC,mCAAmC,EAAE,YAAM;IAC5CnD,mBAAmB,cAACI,IAAA,CAACF,qBAAqB,EAAAkD,aAAA,KAAKvB,SAAS,CAAG,CAAC,CAAC;IAE7D9B,SAAS,CAACsD,SAAS,CAACpD,MAAM,CAACqD,SAAS,CAAC,QAAQ,EAAE;MAAE1B,IAAI,EAAE;IAAW,CAAC,CAAC,CAAC;IACrE2B,MAAM,CAAC1B,SAAS,CAACG,YAAY,CAAC,CAACwB,oBAAoB,CAAC,MAAM,CAAC;IAE3DzD,SAAS,CAAC0D,KAAK,CAACxD,MAAM,CAACqD,SAAS,CAAC,QAAQ,EAAE;MAAE1B,IAAI,EAAE;IAAiB,CAAC,CAAC,CAAC;IACvE2B,MAAM,CAAC1B,SAAS,CAACS,cAAc,CAAC,CAACkB,oBAAoB,CAAC/B,QAAQ,CAAC;EACjE,CAAC,CAAC;EAEF0B,EAAE,CAAC,8CAA8C,EAAE,YAAM;IACvD,IAAMO,cAAc,GAAGrD,IAAI,CAAC4B,EAAE,CAAC,CAAC;IAChC,IAAM0B,cAAc,GAAGtD,IAAI,CAAC4B,EAAE,CAAC,CAAC;IAEhCjC,mBAAmB,cACjBI,IAAA,CAACF,qBAAqB,EAAAkD,aAAA,CAAAA,aAAA,KAChBvB,SAAS;MACb+B,eAAe;MACfC,iBAAiB,EAAC,gBAAgB;MAClCxB,WAAW,EAAC,EAAE;MACdqB,cAAc,EAAEA,cAAe;MAC/BC,cAAc,EAAEA,cAAe;MAC/BzB,KAAK,EAAE,CAACT,QAAQ,EAAE;QAAEC,EAAE,EAAE,CAAC;QAAEP,IAAI,EAAE,SAAS;QAAEK,OAAO,EAAE,MAAM;QAAEG,GAAG,EAAE;UAAED,EAAE,EAAE,CAAC;UAAEE,IAAI,EAAE;QAAO;MAAE,CAAC;IAAE,EAC9F,CACH,CAAC;IAED,IAAMkC,KAAK,GAAG7D,MAAM,CAAC8D,oBAAoB,CAAC,gBAAgB,CAAC;IAC3DhE,SAAS,CAACiE,OAAO,CAACF,KAAK,EAAE;MAAEG,GAAG,EAAE;IAAY,CAAC,CAAC;IAC9ClE,SAAS,CAACiE,OAAO,CAACF,KAAK,EAAE;MAAEG,GAAG,EAAE;IAAQ,CAAC,CAAC;IAC1CV,MAAM,CAAC1B,SAAS,CAACS,cAAc,CAAC,CAACkB,oBAAoB,CAAC;MACpD9B,EAAE,EAAE,CAAC;MACLP,IAAI,EAAE,SAAS;MACfK,OAAO,EAAE,MAAM;MACfG,GAAG,EAAE;QAAED,EAAE,EAAE,CAAC;QAAEE,IAAI,EAAE;MAAO;IAC7B,CAAC,CAAC;IAEF7B,SAAS,CAACiE,OAAO,CAACF,KAAK,EAAE;MAAEG,GAAG,EAAE;IAAS,CAAC,CAAC;IAC3CV,MAAM,CAACI,cAAc,CAAC,CAACO,gBAAgB,CAAC,CAAC;EAC3C,CAAC,CAAC;EAEFf,EAAE,CAAC,gCAAgC,EAAE,YAAM;IACzC,IAAAgB,oBAAA,GAAqBnE,mBAAmB,cAACI,IAAA,CAACF,qBAAqB,EAAAkD,aAAA,CAAAA,aAAA,KAAKvB,SAAS;QAAEM,OAAO;QAACD,KAAK,EAAE;MAAG,EAAE,CAAC,CAAC;MAA7FkC,QAAQ,GAAAD,oBAAA,CAARC,QAAQ;IAChBb,MAAM,CAACtD,MAAM,CAACoE,SAAS,CAAC,aAAa,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAE3DF,QAAQ,cAAChE,IAAA,CAACF,qBAAqB,EAAAkD,aAAA,CAAAA,aAAA,KAAKvB,SAAS;MAAEO,KAAK;MAACF,KAAK,EAAE;IAAG,EAAE,CAAC,CAAC;IACnEqB,MAAM,CAACtD,MAAM,CAACoE,SAAS,CAAC,4BAA4B,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;EAC5E,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/components/atoms/CopyToClipboard.spec.js

@@ -0,0 +1,74 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fireEvent, renderWithProviders, screen } from '../../test/test-utils';
+import { GlobalContextTestProvider } from '../../test/global-context';
+import { CopyToClipboard } from './CopyToClipboard';
+import { jsx as _jsx } from "react/jsx-runtime";
+var event = jest.fn();
+jest.mock('../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatResponse: 'AI_CHAT_RESPONSE'
+    },
+    useEvent: function useEvent() {
+      return event;
+    }
+  };
+});
+jest.mock('./ActionableButton', function () {
+  return {
+    ActionableButton: function ActionableButton(_ref) {
+      var handleClick = _ref.handleClick,
+        tooltip = _ref.tooltip;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        onClick: handleClick,
+        children: tooltip
+      });
+    }
+  };
+});
+describe('CopyToClipboard', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    Object.assign(navigator, {
+      clipboard: {
+        writeText: jest.fn().mockResolvedValue(undefined)
+      }
+    });
+  });
+  it('copies text and tracks analytics', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+            value: {
+              agent: {
+                id: '1',
+                name: 'MAIA',
+                type: 'orchestrator'
+              }
+            },
+            children: /*#__PURE__*/_jsx(CopyToClipboard, {
+              text: "Hello MAIA"
+            })
+          }));
+          fireEvent.click(screen.getByRole('button', {
+            name: 'globals.copy'
+          }));
+          expect(navigator.clipboard.writeText).toHaveBeenCalledWith('Hello MAIA');
+          expect(event).toHaveBeenCalledWith('AI_CHAT_RESPONSE', {
+            agent_type: 'orchestrator',
+            option: 'copy',
+            agent_id: '1',
+            agent_name: 'MAIA'
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/EditableLabel/EditableLabel.spec.js

@@ -0,0 +1,76 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { EditableLabel } from './EditableLabel';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../IconButton', function () {
+  return {
+    IconButton: function IconButton(_ref) {
+      var handleClick = _ref.handleClick,
+        tooltip = _ref.tooltip,
+        disabled = _ref.disabled;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        disabled: disabled,
+        onClick: handleClick,
+        children: tooltip
+      });
+    }
+  };
+});
+describe('EditableLabel', function () {
+  it('renders the value when not editing', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(EditableLabel, {
+      editing: false,
+      value: "Draft title",
+      onSave: jest.fn(),
+      onCancel: jest.fn()
+    }));
+    expect(screen.getByText('Draft title')).toBeInTheDocument();
+  });
+  it('saves the edited value', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var onSave;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          onSave = jest.fn().mockResolvedValue(undefined);
+          renderWithProviders(/*#__PURE__*/_jsx(EditableLabel, {
+            editing: true,
+            value: "Draft title",
+            onSave: onSave,
+            onCancel: jest.fn()
+          }));
+          fireEvent.change(screen.getByDisplayValue('Draft title'), {
+            target: {
+              value: 'Updated title'
+            }
+          });
+          fireEvent.click(screen.getByRole('button', {
+            name: 'globals.save'
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            return expect(onSave).toHaveBeenCalledWith('Updated title');
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('cancels editing on escape', function () {
+    var onCancel = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(EditableLabel, {
+      editing: true,
+      value: "Draft title",
+      onSave: jest.fn(),
+      onCancel: onCancel
+    }));
+    fireEvent.keyDown(screen.getByDisplayValue('Draft title'), {
+      key: 'Escape'
+    });
+    expect(onCancel).toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/EntitySelector/EntitySelector.spec.js

@@ -0,0 +1,86 @@
+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 { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { EntitySelector } from './EntitySelector';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('./EntitySelector.skeleton', function () {
+  return {
+    EntitySelectorSkeleton: function EntitySelectorSkeleton() {
+      return /*#__PURE__*/_jsx("div", {
+        role: "status",
+        children: "Loading entities"
+      });
+    }
+  };
+});
+var translations = {
+  placeholder: 'Buscar proyecto',
+  recentTitle: 'Recientes',
+  searching: 'Buscando',
+  empty: 'Sin resultados',
+  error: 'Error de búsqueda',
+  withoutSecondary: 'Sin cliente'
+};
+var baseProps = {
+  items: [{
+    id: 1,
+    primary: 'Proyecto Alpha',
+    secondary: 'Cliente Uno'
+  }],
+  loading: false,
+  error: false,
+  searchValue: '',
+  onSearchChange: jest.fn(),
+  fetchRecent: jest.fn(),
+  onItemSelected: jest.fn(),
+  translations: translations
+};
+describe('EntitySelector', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    HTMLElement.prototype.scrollIntoView = jest.fn();
+  });
+  it('loads recents on mount and selects an item on click', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(EntitySelector, _objectSpread({}, baseProps)));
+    expect(baseProps.fetchRecent).toHaveBeenCalled();
+    expect(screen.getByText('Recientes')).toBeInTheDocument();
+    fireEvent.click(screen.getByText('Proyecto Alpha'));
+    expect(baseProps.onItemSelected).toHaveBeenCalledWith(baseProps.items[0]);
+  });
+  it('shows search results and supports keyboard selection', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(EntitySelector, _objectSpread(_objectSpread({}, baseProps), {}, {
+      searchValue: "alpha",
+      items: [{
+        id: 1,
+        primary: 'Proyecto Alpha',
+        primaryHighlight: {
+          start: 9,
+          length: 5
+        }
+      }, {
+        id: 2,
+        primary: 'Beta'
+      }]
+    })));
+    var input = screen.getByPlaceholderText('Buscar proyecto');
+    fireEvent.keyDown(input, {
+      key: 'ArrowDown'
+    });
+    fireEvent.keyDown(input, {
+      key: 'Enter'
+    });
+    expect(baseProps.onItemSelected).toHaveBeenCalledWith({
+      id: 2,
+      primary: 'Beta'
+    });
+  });
+  it('renders the error state while searching', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(EntitySelector, _objectSpread(_objectSpread({}, baseProps), {}, {
+      searchValue: "x",
+      error: true
+    })));
+    expect(screen.getByText('Error de búsqueda')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/Expand/Expand.spec.js

@@ -0,0 +1,57 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { Expand } from './Expand';
+import { jsx as _jsx } from "react/jsx-runtime";
+var trackEvent = jest.fn();
+var handleClick = jest.fn();
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      projectResumeExpand: 'PROJECT_RESUME_EXPAND'
+    },
+    useEvent: function useEvent() {
+      return trackEvent;
+    }
+  };
+});
+jest.mock('../IconButton', function () {
+  return {
+    IconButton: function IconButton(_ref) {
+      var onClick = _ref.handleClick,
+        tooltip = _ref.tooltip;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        onClick: onClick,
+        children: tooltip
+      });
+    }
+  };
+});
+describe('Expand', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('tracks expand event and delegates click when collapsed', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(Expand, {
+      expanded: false,
+      handleClick: handleClick
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'globals.expand'
+    }));
+    expect(trackEvent).toHaveBeenCalledWith('PROJECT_RESUME_EXPAND', {
+      expanded: true
+    });
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+  it('shows collapse tooltip when expanded', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(Expand, {
+      expanded: true,
+      handleClick: handleClick
+    }));
+    expect(screen.getByRole('button', {
+      name: 'globals.collapse'
+    })).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/Fade/Fade.spec.js

@@ -0,0 +1,31 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { Fade } from './Fade';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('Fade', function () {
+  it('renders children when visible', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(Fade, {
+      children: /*#__PURE__*/_jsx("p", {
+        children: "contenido"
+      })
+    }));
+    expect(screen.getByText('contenido')).toBeInTheDocument();
+  });
+  it('unmounts children after the exit animation when hidden', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(Fade, {
+        show: true,
+        children: /*#__PURE__*/_jsx("p", {
+          children: "contenido"
+        })
+      })),
+      rerender = _renderWithProviders.rerender;
+    rerender(/*#__PURE__*/_jsx(Fade, {
+      show: false,
+      children: /*#__PURE__*/_jsx("p", {
+        children: "contenido"
+      })
+    }));
+    fireEvent.animationEnd(screen.getByText('contenido').parentElement);
+    expect(screen.queryByText('contenido')).not.toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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