@projectcor/maia-components 2.49.0 → 2.49.1-0

package/lib/components/atoms/MAIAInput/MAIAInputEditor.helpers.spec.js

@@ -0,0 +1,92 @@
+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 { countVisualLinesWrapped, detectMultilineFromCanvas, resolveSingleLineOuterHeight, resolveTextareaContentHeight, resolveVisualLineCounts } from './MAIAInputEditor.helpers';
+describe('MAIAInputEditor.helpers', function () {
+  var measure = function measure(text) {
+    return text.length * 10;
+  };
+  it('returns one line for empty width or single short line', function () {
+    expect(countVisualLinesWrapped('hola', 0, measure)).toBe(1);
+    expect(countVisualLinesWrapped('hola', 200, measure)).toBe(1);
+  });
+  it('wraps words when they exceed the available width', function () {
+    expect(countVisualLinesWrapped('hola mundo largo', 50, measure)).toBeGreaterThan(1);
+  });
+  it('counts explicit newlines as extra lines', function () {
+    expect(countVisualLinesWrapped('linea uno\nlinea dos', 200, measure)).toBe(2);
+  });
+  it('breaks oversized words across multiple lines', function () {
+    expect(countVisualLinesWrapped('supercalifragilistico', 30, measure)).toBeGreaterThan(1);
+  });
+  it('resolveSingleLineOuterHeight sums typography box metrics', function () {
+    expect(resolveSingleLineOuterHeight({
+      lineHeight: 20,
+      paddingTop: 4,
+      paddingBottom: 4,
+      borderTop: 1,
+      borderBottom: 1
+    })).toBe(30);
+  });
+  it('detectMultilineFromCanvas handles multiline text and fallback scroll height', function () {
+    expect(detectMultilineFromCanvas('linea uno\nlinea dos', 200, measure, 20, 30)).toBe(true);
+    expect(detectMultilineFromCanvas('corta', 200, measure, 80, 30)).toBe(true);
+    expect(detectMultilineFromCanvas('corta', 200, measure, 20, 30)).toBe(false);
+  });
+  it('resolveVisualLineCounts uses canvas, scroll fallback and height selection', function () {
+    var canvasContext = {
+      measureText: function measureText(value) {
+        return {
+          width: measure(value)
+        };
+      }
+    };
+    var withCanvas = resolveVisualLineCounts({
+      isEmpty: false,
+      canvasContext: canvasContext,
+      text: 'hola mundo',
+      wrapCheckWidth: 30,
+      textareaWidth: 120,
+      measureSegmentWidth: measure,
+      scrollHeight: 40,
+      singleLineHeight: 30
+    });
+    expect(withCanvas.visualLinesAtWrapWidth).toBeGreaterThan(1);
+    expect(withCanvas.linesForHeight).toBe(1);
+    expect(resolveVisualLineCounts({
+      isEmpty: false,
+      canvasContext: null,
+      text: 'hola',
+      wrapCheckWidth: 30,
+      textareaWidth: 120,
+      measureSegmentWidth: measure,
+      scrollHeight: 80,
+      singleLineHeight: 30
+    }).linesForHeight).toBeGreaterThan(1);
+  });
+  it('resolveTextareaContentHeight snaps single and multiline heights', function () {
+    var base = {
+      minHeight: 20,
+      maxHeight: 170,
+      singleLineOuterHeight: 30,
+      lineHeight: 20,
+      paddingTop: 4,
+      paddingBottom: 4,
+      borderTop: 1,
+      borderBottom: 1
+    };
+    expect(resolveTextareaContentHeight(_objectSpread(_objectSpread({}, base), {}, {
+      isEmpty: true,
+      hasMultipleVisualLines: false,
+      linesForHeight: 1,
+      scrollHeight: 30
+    }))).toBe(30);
+    expect(resolveTextareaContentHeight(_objectSpread(_objectSpread({}, base), {}, {
+      isEmpty: false,
+      hasMultipleVisualLines: true,
+      linesForHeight: 3,
+      scrollHeight: 120
+    }))).toBeGreaterThan(30);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["countVisualLinesWrapped","detectMultilineFromCanvas","resolveSingleLineOuterHeight","resolveTextareaContentHeight","resolveVisualLineCounts","describe","measure","text","length","it","expect","toBe","toBeGreaterThan","lineHeight","paddingTop","paddingBottom","borderTop","borderBottom","canvasContext","measureText","value","width","withCanvas","isEmpty","wrapCheckWidth","textareaWidth","measureSegmentWidth","scrollHeight","singleLineHeight","visualLinesAtWrapWidth","linesForHeight","base","minHeight","maxHeight","singleLineOuterHeight","_objectSpread","hasMultipleVisualLines"],"sources":["../../../../src/components/atoms/MAIAInput/MAIAInputEditor.helpers.spec.ts"],"sourcesContent":["import {\n  countVisualLinesWrapped,\n  detectMultilineFromCanvas,\n  resolveSingleLineOuterHeight,\n  resolveTextareaContentHeight,\n  resolveVisualLineCounts,\n} from './MAIAInputEditor.helpers'\n\ndescribe('MAIAInputEditor.helpers', () => {\n  const measure = (text: string) => text.length * 10\n\n  it('returns one line for empty width or single short line', () => {\n    expect(countVisualLinesWrapped('hola', 0, measure)).toBe(1)\n    expect(countVisualLinesWrapped('hola', 200, measure)).toBe(1)\n  })\n\n  it('wraps words when they exceed the available width', () => {\n    expect(countVisualLinesWrapped('hola mundo largo', 50, measure)).toBeGreaterThan(1)\n  })\n\n  it('counts explicit newlines as extra lines', () => {\n    expect(countVisualLinesWrapped('linea uno\\nlinea dos', 200, measure)).toBe(2)\n  })\n\n  it('breaks oversized words across multiple lines', () => {\n    expect(countVisualLinesWrapped('supercalifragilistico', 30, measure)).toBeGreaterThan(1)\n  })\n\n  it('resolveSingleLineOuterHeight sums typography box metrics', () => {\n    expect(\n      resolveSingleLineOuterHeight({\n        lineHeight: 20,\n        paddingTop: 4,\n        paddingBottom: 4,\n        borderTop: 1,\n        borderBottom: 1,\n      })\n    ).toBe(30)\n  })\n\n  it('detectMultilineFromCanvas handles multiline text and fallback scroll height', () => {\n    expect(detectMultilineFromCanvas('linea uno\\nlinea dos', 200, measure, 20, 30)).toBe(true)\n    expect(detectMultilineFromCanvas('corta', 200, measure, 80, 30)).toBe(true)\n    expect(detectMultilineFromCanvas('corta', 200, measure, 20, 30)).toBe(false)\n  })\n\n  it('resolveVisualLineCounts uses canvas, scroll fallback and height selection', () => {\n    const canvasContext = { measureText: (value: string) => ({ width: measure(value) }) } as CanvasRenderingContext2D\n\n    const withCanvas = resolveVisualLineCounts({\n      isEmpty: false,\n      canvasContext,\n      text: 'hola mundo',\n      wrapCheckWidth: 30,\n      textareaWidth: 120,\n      measureSegmentWidth: measure,\n      scrollHeight: 40,\n      singleLineHeight: 30,\n    })\n    expect(withCanvas.visualLinesAtWrapWidth).toBeGreaterThan(1)\n    expect(withCanvas.linesForHeight).toBe(1)\n\n    expect(\n      resolveVisualLineCounts({\n        isEmpty: false,\n        canvasContext: null,\n        text: 'hola',\n        wrapCheckWidth: 30,\n        textareaWidth: 120,\n        measureSegmentWidth: measure,\n        scrollHeight: 80,\n        singleLineHeight: 30,\n      }).linesForHeight\n    ).toBeGreaterThan(1)\n  })\n\n  it('resolveTextareaContentHeight snaps single and multiline heights', () => {\n    const base = {\n      minHeight: 20,\n      maxHeight: 170,\n      singleLineOuterHeight: 30,\n      lineHeight: 20,\n      paddingTop: 4,\n      paddingBottom: 4,\n      borderTop: 1,\n      borderBottom: 1,\n    }\n\n    expect(\n      resolveTextareaContentHeight({\n        ...base,\n        isEmpty: true,\n        hasMultipleVisualLines: false,\n        linesForHeight: 1,\n        scrollHeight: 30,\n      })\n    ).toBe(30)\n\n    expect(\n      resolveTextareaContentHeight({\n        ...base,\n        isEmpty: false,\n        hasMultipleVisualLines: true,\n        linesForHeight: 3,\n        scrollHeight: 120,\n      })\n    ).toBeGreaterThan(30)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/atoms/MAIAInput/MAIAInputEditor.spec.js

@@ -0,0 +1,193 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { createRef } from 'react';
+import { act, fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { MAIAInputEditor } from './MAIAInputEditor';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('MAIAInputEditor', function () {
+  it('notifies typing presence and sends on Enter', function () {
+    var inputRef = /*#__PURE__*/createRef();
+    var onTypingPresenceChange = jest.fn();
+    var onEnterSend = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(MAIAInputEditor, {
+      inputRef: inputRef,
+      clearSeq: 0,
+      sendDisabled: false,
+      setIsTextMultiline: jest.fn(),
+      onTypingPresenceChange: onTypingPresenceChange,
+      onEnterSend: onEnterSend,
+      placeholder: "Escrib\xED"
+    }));
+    var textarea = screen.getByPlaceholderText('Escribí');
+    fireEvent.change(textarea, {
+      target: {
+        value: 'hola'
+      }
+    });
+    expect(onTypingPresenceChange).toHaveBeenCalledWith(true);
+    fireEvent.keyDown(textarea, {
+      key: 'Enter'
+    });
+    expect(onEnterSend).toHaveBeenCalled();
+  });
+  it('syncs typing presence on blur and clears height on clearSeq', function () {
+    var inputRef = /*#__PURE__*/createRef();
+    var onTypingPresenceChange = jest.fn();
+    var setIsTextMultiline = jest.fn();
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(MAIAInputEditor, {
+        inputRef: inputRef,
+        clearSeq: 0,
+        sendDisabled: false,
+        setIsTextMultiline: setIsTextMultiline,
+        onTypingPresenceChange: onTypingPresenceChange,
+        onEnterSend: jest.fn(),
+        onChangeProp: jest.fn()
+      })),
+      rerender = _renderWithProviders.rerender;
+    var textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, {
+      target: {
+        value: '   '
+      }
+    });
+    expect(onTypingPresenceChange).not.toHaveBeenCalledWith(true);
+    fireEvent.change(textarea, {
+      target: {
+        value: 'hola'
+      }
+    });
+    fireEvent.blur(textarea);
+    expect(onTypingPresenceChange).toHaveBeenCalledWith(true);
+    rerender(/*#__PURE__*/_jsx(MAIAInputEditor, {
+      inputRef: inputRef,
+      clearSeq: 1,
+      sendDisabled: false,
+      setIsTextMultiline: setIsTextMultiline,
+      onTypingPresenceChange: onTypingPresenceChange,
+      onEnterSend: jest.fn()
+    }));
+    expect(setIsTextMultiline).toHaveBeenCalled();
+  });
+  it('recomputes layout on chat changes and animation frames', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var inputRef, setIsTextMultiline, _renderWithProviders2, rerender, textarea;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          inputRef = /*#__PURE__*/createRef();
+          setIsTextMultiline = jest.fn();
+          _renderWithProviders2 = renderWithProviders(/*#__PURE__*/_jsx(MAIAInputEditor, {
+            inputRef: inputRef,
+            clearSeq: 0,
+            chatId: "chat-1",
+            sendDisabled: false,
+            setIsTextMultiline: setIsTextMultiline,
+            onTypingPresenceChange: jest.fn(),
+            onEnterSend: jest.fn()
+          })), rerender = _renderWithProviders2.rerender;
+          textarea = screen.getByRole('textbox');
+          fireEvent.change(textarea, {
+            target: {
+              value: 'texto largo que debería medirse en el resize del editor'
+            }
+          });
+          _context3.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 new Promise(function (resolve) {
+                    requestAnimationFrame(function () {
+                      return resolve();
+                    });
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          rerender(/*#__PURE__*/_jsx(MAIAInputEditor, {
+            inputRef: inputRef,
+            clearSeq: 2,
+            chatId: "chat-2",
+            newChatKey: 1,
+            sendDisabled: false,
+            setIsTextMultiline: setIsTextMultiline,
+            onTypingPresenceChange: jest.fn(),
+            onEnterSend: jest.fn()
+          }));
+          _context3.next = 2;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+            return _regeneratorRuntime.wrap(function (_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  _context2.next = 1;
+                  return new Promise(function (resolve) {
+                    requestAnimationFrame(function () {
+                      return resolve();
+                    });
+                  });
+                case 1:
+                case "end":
+                  return _context2.stop();
+              }
+            }, _callee2);
+          })));
+        case 2:
+          expect(setIsTextMultiline).toHaveBeenCalled();
+        case 3:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('marks multiline text and respects disabled send', function () {
+    var inputRef = /*#__PURE__*/createRef();
+    var setIsTextMultiline = jest.fn();
+    var onEnterSend = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(MAIAInputEditor, {
+      inputRef: inputRef,
+      clearSeq: 0,
+      sendDisabled: false,
+      disabled: true,
+      setIsTextMultiline: setIsTextMultiline,
+      onTypingPresenceChange: jest.fn(),
+      onEnterSend: onEnterSend
+    }));
+    var textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, {
+      target: {
+        value: 'linea uno\nlinea dos\nlinea tres extra larga para forzar resize'
+      }
+    });
+    fireEvent.keyDown(textarea, {
+      key: 'Enter'
+    });
+    expect(onEnterSend).not.toHaveBeenCalled();
+    expect(setIsTextMultiline).toHaveBeenCalled();
+  });
+  it('does not send on Shift+Enter or when send is disabled', function () {
+    var inputRef = /*#__PURE__*/createRef();
+    var onEnterSend = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(MAIAInputEditor, {
+      inputRef: inputRef,
+      clearSeq: 0,
+      sendDisabled: true,
+      setIsTextMultiline: jest.fn(),
+      onTypingPresenceChange: jest.fn(),
+      onEnterSend: onEnterSend
+    }));
+    var textarea = screen.getByRole('textbox');
+    fireEvent.keyDown(textarea, {
+      key: 'Enter',
+      shiftKey: true
+    });
+    fireEvent.keyDown(textarea, {
+      key: 'Enter'
+    });
+    expect(onEnterSend).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["createRef","act","fireEvent","renderWithProviders","screen","MAIAInputEditor","jsx","_jsx","describe","it","inputRef","onTypingPresenceChange","jest","fn","onEnterSend","clearSeq","sendDisabled","setIsTextMultiline","placeholder","textarea","getByPlaceholderText","change","target","value","expect","toHaveBeenCalledWith","keyDown","key","toHaveBeenCalled","_renderWithProviders","onChangeProp","rerender","getByRole","not","blur","_asyncToGenerator","_regeneratorRuntime","mark","_callee3","_renderWithProviders2","wrap","_context3","prev","next","chatId","_callee","_context","Promise","resolve","requestAnimationFrame","stop","newChatKey","_callee2","_context2","disabled","shiftKey"],"sources":["../../../../src/components/atoms/MAIAInput/MAIAInputEditor.spec.tsx"],"sourcesContent":["import { createRef } from 'react'\nimport { act, fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { MAIAInputEditor } from './MAIAInputEditor'\n\ndescribe('MAIAInputEditor', () => {\n  it('notifies typing presence and sends on Enter', () => {\n    const inputRef = createRef<HTMLTextAreaElement>()\n    const onTypingPresenceChange = jest.fn()\n    const onEnterSend = jest.fn()\n\n    renderWithProviders(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={0}\n        sendDisabled={false}\n        setIsTextMultiline={jest.fn()}\n        onTypingPresenceChange={onTypingPresenceChange}\n        onEnterSend={onEnterSend}\n        placeholder=\"Escribí\"\n      />\n    )\n\n    const textarea = screen.getByPlaceholderText('Escribí')\n    fireEvent.change(textarea, { target: { value: 'hola' } })\n    expect(onTypingPresenceChange).toHaveBeenCalledWith(true)\n\n    fireEvent.keyDown(textarea, { key: 'Enter' })\n    expect(onEnterSend).toHaveBeenCalled()\n  })\n\n  it('syncs typing presence on blur and clears height on clearSeq', () => {\n    const inputRef = createRef<HTMLTextAreaElement>()\n    const onTypingPresenceChange = jest.fn()\n    const setIsTextMultiline = jest.fn()\n\n    const { rerender } = renderWithProviders(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={0}\n        sendDisabled={false}\n        setIsTextMultiline={setIsTextMultiline}\n        onTypingPresenceChange={onTypingPresenceChange}\n        onEnterSend={jest.fn()}\n        onChangeProp={jest.fn()}\n      />\n    )\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.change(textarea, { target: { value: '   ' } })\n    expect(onTypingPresenceChange).not.toHaveBeenCalledWith(true)\n\n    fireEvent.change(textarea, { target: { value: 'hola' } })\n    fireEvent.blur(textarea)\n    expect(onTypingPresenceChange).toHaveBeenCalledWith(true)\n\n    rerender(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={1}\n        sendDisabled={false}\n        setIsTextMultiline={setIsTextMultiline}\n        onTypingPresenceChange={onTypingPresenceChange}\n        onEnterSend={jest.fn()}\n      />\n    )\n\n    expect(setIsTextMultiline).toHaveBeenCalled()\n  })\n\n  it('recomputes layout on chat changes and animation frames', async () => {\n    const inputRef = createRef<HTMLTextAreaElement>()\n    const setIsTextMultiline = jest.fn()\n\n    const { rerender } = renderWithProviders(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={0}\n        chatId=\"chat-1\"\n        sendDisabled={false}\n        setIsTextMultiline={setIsTextMultiline}\n        onTypingPresenceChange={jest.fn()}\n        onEnterSend={jest.fn()}\n      />\n    )\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.change(textarea, { target: { value: 'texto largo que debería medirse en el resize del editor' } })\n\n    await act(async () => {\n      await new Promise<void>(resolve => {\n        requestAnimationFrame(() => resolve())\n      })\n    })\n\n    rerender(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={2}\n        chatId=\"chat-2\"\n        newChatKey={1}\n        sendDisabled={false}\n        setIsTextMultiline={setIsTextMultiline}\n        onTypingPresenceChange={jest.fn()}\n        onEnterSend={jest.fn()}\n      />\n    )\n\n    await act(async () => {\n      await new Promise<void>(resolve => {\n        requestAnimationFrame(() => resolve())\n      })\n    })\n\n    expect(setIsTextMultiline).toHaveBeenCalled()\n  })\n\n  it('marks multiline text and respects disabled send', () => {\n    const inputRef = createRef<HTMLTextAreaElement>()\n    const setIsTextMultiline = jest.fn()\n    const onEnterSend = jest.fn()\n\n    renderWithProviders(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={0}\n        sendDisabled={false}\n        disabled\n        setIsTextMultiline={setIsTextMultiline}\n        onTypingPresenceChange={jest.fn()}\n        onEnterSend={onEnterSend}\n      />\n    )\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.change(textarea, {\n      target: { value: 'linea uno\\nlinea dos\\nlinea tres extra larga para forzar resize' },\n    })\n    fireEvent.keyDown(textarea, { key: 'Enter' })\n\n    expect(onEnterSend).not.toHaveBeenCalled()\n    expect(setIsTextMultiline).toHaveBeenCalled()\n  })\n\n  it('does not send on Shift+Enter or when send is disabled', () => {\n    const inputRef = createRef<HTMLTextAreaElement>()\n    const onEnterSend = jest.fn()\n\n    renderWithProviders(\n      <MAIAInputEditor\n        inputRef={inputRef}\n        clearSeq={0}\n        sendDisabled\n        setIsTextMultiline={jest.fn()}\n        onTypingPresenceChange={jest.fn()}\n        onEnterSend={onEnterSend}\n      />\n    )\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.keyDown(textarea, { key: 'Enter', shiftKey: true })\n    fireEvent.keyDown(textarea, { key: 'Enter' })\n    expect(onEnterSend).not.toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/atoms/MAIAInput/maiaInputLayout.spec.js

@@ -0,0 +1,32 @@
+import { getMaiaInputEditorMaxHeight, MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX, MAIA_INPUT_EDITOR_MIN_HEIGHT_PX, MAIA_INPUT_TOOLBAR_ROW_HEIGHT_PX, MAIA_INPUT_WRAPPER_MAX_HEIGHT_PX } from './maiaInputLayout';
+describe('maiaInputLayout', function () {
+  it('reserves space for toolbar and padding when there are no chips', function () {
+    expect(MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX).toBe(MAIA_INPUT_WRAPPER_MAX_HEIGHT_PX - 16 - 4 - MAIA_INPUT_TOOLBAR_ROW_HEIGHT_PX);
+  });
+  it('shrinks the editor when chips are visible', function () {
+    expect(getMaiaInputEditorMaxHeight({
+      chipsRowHeightPx: 40
+    })).toBeLessThan(MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX);
+  });
+  it('never goes below the editor minimum height', function () {
+    expect(getMaiaInputEditorMaxHeight({
+      chipsRowHeightPx: 500
+    })).toBe(MAIA_INPUT_EDITOR_MIN_HEIGHT_PX);
+  });
+  it('ignores chips block when chip row height is zero', function () {
+    expect(getMaiaInputEditorMaxHeight({
+      chipsRowHeightPx: 0
+    })).toBe(MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX);
+  });
+  it('uses the larger of custom toolbar height and the default minimum', function () {
+    expect(getMaiaInputEditorMaxHeight({
+      chipsRowHeightPx: 0,
+      toolbarRowHeightPx: 48
+    })).toBeLessThan(MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX);
+    expect(getMaiaInputEditorMaxHeight({
+      chipsRowHeightPx: 0,
+      toolbarRowHeightPx: 8
+    })).toBe(MAIA_INPUT_EDITOR_MAX_HEIGHT_NO_CHIPS_PX);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,64 @@
+import { renderWithProviders, screen } from '../../../test/test-utils';
+import { ensureStreamdownStyles } from '../../../utils/ensureStreamdownStyles';
+import { MaiaStreamdown } from './MaiaStreamdown';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('./MaiaStreamdown.config', function () {
+  return {
+    MAIA_STREAMDOWN_CODE_PLUGIN: {},
+    MAIA_STREAMDOWN_DEFAULT_CONTROLS: {
+      table: false,
+      code: false
+    },
+    MAIA_STREAMDOWN_DEFAULT_REHYPE_PLUGINS: [],
+    MAIA_STREAMDOWN_LINK_SAFETY_BY_VARIANT: {
+      chat: {
+        enabled: false
+      },
+      preview: {
+        enabled: true
+      },
+      compact: {
+        enabled: false
+      }
+    },
+    MAIA_STREAMDOWN_SHIKI_THEME: ['github-light', 'github-light']
+  };
+});
+jest.mock('../../../utils/ensureStreamdownStyles', function () {
+  return {
+    ensureStreamdownStyles: jest.fn()
+  };
+});
+describe('MaiaStreamdown', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('renders markdown with chat link safety defaults', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaStreamdown, {
+      variant: "chat",
+      children: "Hola **mundo**"
+    }));
+    expect(ensureStreamdownStyles).toHaveBeenCalled();
+    expect(screen.getByTestId('streamdown')).toHaveAttribute('data-link-enabled', 'false');
+    expect(screen.getByText('Hola **mundo**')).toBeInTheDocument();
+    expect(screen.getByText('Hola **mundo**').closest('[data-maia-streamdown="chat"]')).toBeInTheDocument();
+  });
+  it('enables link safety for preview variant unless overridden', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaStreamdown, {
+      variant: "preview",
+      children: "Link"
+    }));
+    expect(screen.getByTestId('streamdown')).toHaveAttribute('data-link-enabled', 'true');
+  });
+  it('respects explicit linkSafety prop', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaStreamdown, {
+      variant: "chat",
+      linkSafety: {
+        enabled: true
+      },
+      children: "Custom"
+    }));
+    expect(screen.getByTestId('streamdown')).toHaveAttribute('data-link-enabled', 'true');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJyZW5kZXJXaXRoUHJvdmlkZXJzIiwic2NyZWVuIiwiZW5zdXJlU3RyZWFtZG93blN0eWxlcyIsIk1haWFTdHJlYW1kb3duIiwianN4IiwiX2pzeCIsImplc3QiLCJtb2NrIiwiTUFJQV9TVFJFQU1ET1dOX0NPREVfUExVR0lOIiwiTUFJQV9TVFJFQU1ET1dOX0RFRkFVTFRfQ09OVFJPTFMiLCJ0YWJsZSIsImNvZGUiLCJNQUlBX1NUUkVBTURPV05fREVGQVVMVF9SRUhZUEVfUExVR0lOUyIsIk1BSUFfU1RSRUFNRE9XTl9MSU5LX1NBRkVUWV9CWV9WQVJJQU5UIiwiY2hhdCIsImVuYWJsZWQiLCJwcmV2aWV3IiwiY29tcGFjdCIsIk1BSUFfU1RSRUFNRE9XTl9TSElLSV9USEVNRSIsImZuIiwiZGVzY3JpYmUiLCJiZWZvcmVFYWNoIiwiY2xlYXJBbGxNb2NrcyIsIml0IiwidmFyaWFudCIsImNoaWxkcmVuIiwiZXhwZWN0IiwidG9IYXZlQmVlbkNhbGxlZCIsImdldEJ5VGVzdElkIiwidG9IYXZlQXR0cmlidXRlIiwiZ2V0QnlUZXh0IiwidG9CZUluVGhlRG9jdW1lbnQiLCJjbG9zZXN0IiwibGlua1NhZmV0eSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL2F0b21zL01haWFTdHJlYW1kb3duL01haWFTdHJlYW1kb3duLnNwZWMudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHJlbmRlcldpdGhQcm92aWRlcnMsIHNjcmVlbiB9IGZyb20gJy4uLy4uLy4uL3Rlc3QvdGVzdC11dGlscydcbmltcG9ydCB7IGVuc3VyZVN0cmVhbWRvd25TdHlsZXMgfSBmcm9tICcuLi8uLi8uLi91dGlscy9lbnN1cmVTdHJlYW1kb3duU3R5bGVzJ1xuaW1wb3J0IHsgTWFpYVN0cmVhbWRvd24gfSBmcm9tICcuL01haWFTdHJlYW1kb3duJ1xuXG5qZXN0Lm1vY2soJy4vTWFpYVN0cmVhbWRvd24uY29uZmlnJywgKCkgPT4gKHtcbiAgTUFJQV9TVFJFQU1ET1dOX0NPREVfUExVR0lOOiB7fSxcbiAgTUFJQV9TVFJFQU1ET1dOX0RFRkFVTFRfQ09OVFJPTFM6IHsgdGFibGU6IGZhbHNlLCBjb2RlOiBmYWxzZSB9LFxuICBNQUlBX1NUUkVBTURPV05fREVGQVVMVF9SRUhZUEVfUExVR0lOUzogW10sXG4gIE1BSUFfU1RSRUFNRE9XTl9MSU5LX1NBRkVUWV9CWV9WQVJJQU5UOiB7XG4gICAgY2hhdDogeyBlbmFibGVkOiBmYWxzZSB9LFxuICAgIHByZXZpZXc6IHsgZW5hYmxlZDogdHJ1ZSB9LFxuICAgIGNvbXBhY3Q6IHsgZW5hYmxlZDogZmFsc2UgfSxcbiAgfSxcbiAgTUFJQV9TVFJFQU1ET1dOX1NISUtJX1RIRU1FOiBbJ2dpdGh1Yi1saWdodCcsICdnaXRodWItbGlnaHQnXSxcbn0pKVxuXG5qZXN0Lm1vY2soJy4uLy4uLy4uL3V0aWxzL2Vuc3VyZVN0cmVhbWRvd25TdHlsZXMnLCAoKSA9PiAoe1xuICBlbnN1cmVTdHJlYW1kb3duU3R5bGVzOiBqZXN0LmZuKCksXG59KSlcblxuZGVzY3JpYmUoJ01haWFTdHJlYW1kb3duJywgKCkgPT4ge1xuICBiZWZvcmVFYWNoKCgpID0+IHtcbiAgICBqZXN0LmNsZWFyQWxsTW9ja3MoKVxuICB9KVxuXG4gIGl0KCdyZW5kZXJzIG1hcmtkb3duIHdpdGggY2hhdCBsaW5rIHNhZmV0eSBkZWZhdWx0cycsICgpID0+IHtcbiAgICByZW5kZXJXaXRoUHJvdmlkZXJzKDxNYWlhU3RyZWFtZG93biB2YXJpYW50PVwiY2hhdFwiPkhvbGEgKiptdW5kbyoqPC9NYWlhU3RyZWFtZG93bj4pXG5cbiAgICBleHBlY3QoZW5zdXJlU3RyZWFtZG93blN0eWxlcykudG9IYXZlQmVlbkNhbGxlZCgpXG4gICAgZXhwZWN0KHNjcmVlbi5nZXRCeVRlc3RJZCgnc3RyZWFtZG93bicpKS50b0hhdmVBdHRyaWJ1dGUoJ2RhdGEtbGluay1lbmFibGVkJywgJ2ZhbHNlJylcbiAgICBleHBlY3Qoc2NyZWVuLmdldEJ5VGV4dCgnSG9sYSAqKm11bmRvKionKSkudG9CZUluVGhlRG9jdW1lbnQoKVxuICAgIGV4cGVjdChzY3JlZW4uZ2V0QnlUZXh0KCdIb2xhICoqbXVuZG8qKicpLmNsb3Nlc3QoJ1tkYXRhLW1haWEtc3RyZWFtZG93bj1cImNoYXRcIl0nKSkudG9CZUluVGhlRG9jdW1lbnQoKVxuICB9KVxuXG4gIGl0KCdlbmFibGVzIGxpbmsgc2FmZXR5IGZvciBwcmV2aWV3IHZhcmlhbnQgdW5sZXNzIG92ZXJyaWRkZW4nLCAoKSA9PiB7XG4gICAgcmVuZGVyV2l0aFByb3ZpZGVycyg8TWFpYVN0cmVhbWRvd24gdmFyaWFudD1cInByZXZpZXdcIj5MaW5rPC9NYWlhU3RyZWFtZG93bj4pXG5cbiAgICBleHBlY3Qoc2NyZWVuLmdldEJ5VGVzdElkKCdzdHJlYW1kb3duJykpLnRvSGF2ZUF0dHJpYnV0ZSgnZGF0YS1saW5rLWVuYWJsZWQnLCAndHJ1ZScpXG4gIH0pXG5cbiAgaXQoJ3Jlc3BlY3RzIGV4cGxpY2l0IGxpbmtTYWZldHkgcHJvcCcsICgpID0+IHtcbiAgICByZW5kZXJXaXRoUHJvdmlkZXJzKFxuICAgICAgPE1haWFTdHJlYW1kb3duIHZhcmlhbnQ9XCJjaGF0XCIgbGlua1NhZmV0eT17eyBlbmFibGVkOiB0cnVlIH19PlxuICAgICAgICBDdXN0b21cbiAgICAgIDwvTWFpYVN0cmVhbWRvd24+XG4gICAgKVxuXG4gICAgZXhwZWN0KHNjcmVlbi5nZXRCeVRlc3RJZCgnc3RyZWFtZG93bicpKS50b0hhdmVBdHRyaWJ1dGUoJ2RhdGEtbGluay1lbmFibGVkJywgJ3RydWUnKVxuICB9KVxufSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsbUJBQW1CLEVBQUVDLE1BQU0sUUFBUSwwQkFBMEI7QUFDdEUsU0FBU0Msc0JBQXNCLFFBQVEsdUNBQXVDO0FBQzlFLFNBQVNDLGNBQWMsUUFBUSxrQkFBa0I7QUFBQSxTQUFBQyxHQUFBLElBQUFDLElBQUE7QUFFakRDLElBQUksQ0FBQ0MsSUFBSSxDQUFDLHlCQUF5QixFQUFFO0VBQUEsT0FBTztJQUMxQ0MsMkJBQTJCLEVBQUUsQ0FBQyxDQUFDO0lBQy9CQyxnQ0FBZ0MsRUFBRTtNQUFFQyxLQUFLLEVBQUUsS0FBSztNQUFFQyxJQUFJLEVBQUU7SUFBTSxDQUFDO0lBQy9EQyxzQ0FBc0MsRUFBRSxFQUFFO0lBQzFDQyxzQ0FBc0MsRUFBRTtNQUN0Q0MsSUFBSSxFQUFFO1FBQUVDLE9BQU8sRUFBRTtNQUFNLENBQUM7TUFDeEJDLE9BQU8sRUFBRTtRQUFFRCxPQUFPLEVBQUU7TUFBSyxDQUFDO01BQzFCRSxPQUFPLEVBQUU7UUFBRUYsT0FBTyxFQUFFO01BQU07SUFDNUIsQ0FBQztJQUNERywyQkFBMkIsRUFBRSxDQUFDLGNBQWMsRUFBRSxjQUFjO0VBQzlELENBQUM7QUFBQSxDQUFDLENBQUM7QUFFSFosSUFBSSxDQUFDQyxJQUFJLENBQUMsdUNBQXVDLEVBQUU7RUFBQSxPQUFPO0lBQ3hETCxzQkFBc0IsRUFBRUksSUFBSSxDQUFDYSxFQUFFLENBQUM7RUFDbEMsQ0FBQztBQUFBLENBQUMsQ0FBQztBQUVIQyxRQUFRLENBQUMsZ0JBQWdCLEVBQUUsWUFBTTtFQUMvQkMsVUFBVSxDQUFDLFlBQU07SUFDZmYsSUFBSSxDQUFDZ0IsYUFBYSxDQUFDLENBQUM7RUFDdEIsQ0FBQyxDQUFDO0VBRUZDLEVBQUUsQ0FBQyxpREFBaUQsRUFBRSxZQUFNO0lBQzFEdkIsbUJBQW1CLGNBQUNLLElBQUEsQ0FBQ0YsY0FBYztNQUFDcUIsT0FBTyxFQUFDLE1BQU07TUFBQUMsUUFBQSxFQUFDO0lBQWMsQ0FBZ0IsQ0FBQyxDQUFDO0lBRW5GQyxNQUFNLENBQUN4QixzQkFBc0IsQ0FBQyxDQUFDeUIsZ0JBQWdCLENBQUMsQ0FBQztJQUNqREQsTUFBTSxDQUFDekIsTUFBTSxDQUFDMkIsV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUNDLGVBQWUsQ0FBQyxtQkFBbUIsRUFBRSxPQUFPLENBQUM7SUFDdEZILE1BQU0sQ0FBQ3pCLE1BQU0sQ0FBQzZCLFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUNDLGlCQUFpQixDQUFDLENBQUM7SUFDOURMLE1BQU0sQ0FBQ3pCLE1BQU0sQ0FBQzZCLFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDRSxPQUFPLENBQUMsK0JBQStCLENBQUMsQ0FBQyxDQUFDRCxpQkFBaUIsQ0FBQyxDQUFDO0VBQ3pHLENBQUMsQ0FBQztFQUVGUixFQUFFLENBQUMsMkRBQTJELEVBQUUsWUFBTTtJQUNwRXZCLG1CQUFtQixjQUFDSyxJQUFBLENBQUNGLGNBQWM7TUFBQ3FCLE9BQU8sRUFBQyxTQUFTO01BQUFDLFFBQUEsRUFBQztJQUFJLENBQWdCLENBQUMsQ0FBQztJQUU1RUMsTUFBTSxDQUFDekIsTUFBTSxDQUFDMkIsV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUNDLGVBQWUsQ0FBQyxtQkFBbUIsRUFBRSxNQUFNLENBQUM7RUFDdkYsQ0FBQyxDQUFDO0VBRUZOLEVBQUUsQ0FBQyxtQ0FBbUMsRUFBRSxZQUFNO0lBQzVDdkIsbUJBQW1CLGNBQ2pCSyxJQUFBLENBQUNGLGNBQWM7TUFBQ3FCLE9BQU8sRUFBQyxNQUFNO01BQUNTLFVBQVUsRUFBRTtRQUFFbEIsT0FBTyxFQUFFO01BQUssQ0FBRTtNQUFBVSxRQUFBLEVBQUM7SUFFOUQsQ0FBZ0IsQ0FDbEIsQ0FBQztJQUVEQyxNQUFNLENBQUN6QixNQUFNLENBQUMyQixXQUFXLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQ0MsZUFBZSxDQUFDLG1CQUFtQixFQUFFLE1BQU0sQ0FBQztFQUN2RixDQUFDLENBQUM7QUFDSixDQUFDLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

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

@@ -0,0 +1,43 @@
+import { renderWithProviders, screen } from '../../../test/test-utils';
+import { MaiaWrapper } from './MaiaWrapper';
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+jest.mock('./MaiaWrapperBase', function () {
+  return {
+    MaiaWrapperBase: function MaiaWrapperBase(_ref) {
+      var children = _ref.children;
+      return /*#__PURE__*/_jsxs("div", {
+        children: ["classic-wrapper", children]
+      });
+    }
+  };
+});
+jest.mock('./ModernMaiaWrapper', function () {
+  return {
+    ModernMaiaWrapper: function ModernMaiaWrapper(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_jsxs("div", {
+        children: ["modern-wrapper", children]
+      });
+    }
+  };
+});
+describe('MaiaWrapper', function () {
+  it('uses the classic wrapper by default', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaWrapper, {
+      children: /*#__PURE__*/_jsx("span", {
+        children: "body"
+      })
+    }));
+    expect(screen.getByText(/classic-wrapper/)).toBeInTheDocument();
+  });
+  it('uses the modern wrapper when requested', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(MaiaWrapper, {
+      wrapperStyle: "modern",
+      children: /*#__PURE__*/_jsx("span", {
+        children: "body"
+      })
+    }));
+    expect(screen.getByText(/modern-wrapper/)).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/MaiaWrapper/MaiaWrapperBase.spec.js

@@ -0,0 +1,114 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { GlobalContextTestProvider } from '../../../test/global-context';
+import { SECTIONS } from '../../../constants/config';
+import { MaiaWrapperBase } from './MaiaWrapperBase';
+import { jsx as _jsx } from "react/jsx-runtime";
+var trackEvent = jest.fn();
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      projectResumeClose: 'PROJECT_RESUME_CLOSE'
+    },
+    useEvent: function useEvent() {
+      return trackEvent;
+    }
+  };
+});
+jest.mock('../HelpButton', function () {
+  return {
+    HelpButton: function HelpButton() {
+      return /*#__PURE__*/_jsx("span", {
+        children: "help-button"
+      });
+    }
+  };
+});
+jest.mock('../Expand', function () {
+  return {
+    Expand: function Expand(_ref) {
+      var handleClick = _ref.handleClick;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": "globals.expand",
+        onClick: handleClick,
+        children: "expand"
+      });
+    }
+  };
+});
+jest.mock('../IconButton', function () {
+  return {
+    IconButton: function IconButton(_ref2) {
+      var handleClick = _ref2.handleClick,
+        tooltip = _ref2.tooltip;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        onClick: handleClick,
+        children: "close"
+      });
+    }
+  };
+});
+describe('MaiaWrapperBase', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('renders brand, children, help, and custom left actions', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        section: SECTIONS.projectSummary
+      },
+      children: /*#__PURE__*/_jsx(MaiaWrapperBase, {
+        leftActions: [/*#__PURE__*/_jsx("span", {
+          children: "extra-action"
+        }, "custom")],
+        children: /*#__PURE__*/_jsx("p", {
+          children: "panel-body"
+        })
+      })
+    }));
+    expect(screen.getByText('globals.brandName')).toBeInTheDocument();
+    expect(screen.getByText('panel-body')).toBeInTheDocument();
+    expect(screen.getByText('help-button')).toBeInTheDocument();
+    expect(screen.getByText('extra-action')).toBeInTheDocument();
+  });
+  it('tracks close event and calls handleClose', function () {
+    var handleClose = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        section: SECTIONS.chatAI
+      },
+      children: /*#__PURE__*/_jsx(MaiaWrapperBase, {
+        handleClose: handleClose,
+        children: /*#__PURE__*/_jsx("p", {
+          children: "content"
+        })
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'globals.close'
+    }));
+    expect(trackEvent).toHaveBeenCalledWith('PROJECT_RESUME_CLOSE');
+    expect(handleClose).toHaveBeenCalledTimes(1);
+  });
+  it('toggles expand control without closing', function () {
+    var handleClose = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      value: {
+        section: SECTIONS.chatAI
+      },
+      children: /*#__PURE__*/_jsx(MaiaWrapperBase, {
+        handleClose: handleClose,
+        children: /*#__PURE__*/_jsx("p", {
+          children: "content"
+        })
+      })
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'globals.expand'
+    }));
+    expect(handleClose).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","GlobalContextTestProvider","SECTIONS","MaiaWrapperBase","jsx","_jsx","trackEvent","jest","fn","mock","EVENTS","projectResumeClose","useEvent","HelpButton","children","Expand","_ref","handleClick","type","onClick","IconButton","_ref2","tooltip","describe","beforeEach","clearAllMocks","it","value","section","projectSummary","leftActions","expect","getByText","toBeInTheDocument","handleClose","chatAI","click","getByRole","name","toHaveBeenCalledWith","toHaveBeenCalledTimes","not","toHaveBeenCalled"],"sources":["../../../../src/components/atoms/MaiaWrapper/MaiaWrapperBase.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider } from '../../../test/global-context'\nimport { SECTIONS } from '../../../constants/config'\nimport { MaiaWrapperBase } from './MaiaWrapperBase'\n\nconst trackEvent = jest.fn()\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: { projectResumeClose: 'PROJECT_RESUME_CLOSE' },\n  useEvent: () => trackEvent,\n}))\n\njest.mock('../HelpButton', () => ({\n  HelpButton: () => <span>help-button</span>,\n}))\n\njest.mock('../Expand', () => ({\n  Expand: ({ handleClick }: { handleClick: () => void }) => (\n    <button type=\"button\" aria-label=\"globals.expand\" onClick={handleClick}>\n      expand\n    </button>\n  ),\n}))\n\njest.mock('../IconButton', () => ({\n  IconButton: ({ handleClick, tooltip }: { handleClick?: () => void; tooltip: string }) => (\n    <button type=\"button\" aria-label={tooltip} onClick={handleClick}>\n      close\n    </button>\n  ),\n}))\n\ndescribe('MaiaWrapperBase', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n  })\n\n  it('renders brand, children, help, and custom left actions', () => {\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ section: SECTIONS.projectSummary }}>\n        <MaiaWrapperBase leftActions={[<span key=\"custom\">extra-action</span>]}>\n          <p>panel-body</p>\n        </MaiaWrapperBase>\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('globals.brandName')).toBeInTheDocument()\n    expect(screen.getByText('panel-body')).toBeInTheDocument()\n    expect(screen.getByText('help-button')).toBeInTheDocument()\n    expect(screen.getByText('extra-action')).toBeInTheDocument()\n  })\n\n  it('tracks close event and calls handleClose', () => {\n    const handleClose = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ section: SECTIONS.chatAI }}>\n        <MaiaWrapperBase handleClose={handleClose}>\n          <p>content</p>\n        </MaiaWrapperBase>\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'globals.close' }))\n\n    expect(trackEvent).toHaveBeenCalledWith('PROJECT_RESUME_CLOSE')\n    expect(handleClose).toHaveBeenCalledTimes(1)\n  })\n\n  it('toggles expand control without closing', () => {\n    const handleClose = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider value={{ section: SECTIONS.chatAI }}>\n        <MaiaWrapperBase handleClose={handleClose}>\n          <p>content</p>\n        </MaiaWrapperBase>\n      </GlobalContextTestProvider>\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'globals.expand' }))\n\n    expect(handleClose).not.toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}