@projectcor/maia-components 2.49.0-beta.1 → 2.49.1-0

package/lib/hooks/useSmoothStreamText/useSmoothStreamText.spec.js

@@ -0,0 +1,101 @@
+import { act, renderHook } from '@testing-library/react';
+import { useSmoothStreamText } from './useSmoothStreamText';
+describe('useSmoothStreamText', function () {
+  beforeEach(function () {
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+  });
+  it('returns the target immediately when animation is disabled', function () {
+    var _renderHook = renderHook(function () {
+        return useSmoothStreamText('hello world', {
+          enabled: false
+        });
+      }),
+      result = _renderHook.result;
+    expect(result.current).toBe('hello world');
+  });
+  it('starts empty and progressively reveals text while enabled', function () {
+    var _renderHook2 = renderHook(function () {
+        return useSmoothStreamText('Hello there', {
+          enabled: true,
+          warmupMs: 0,
+          targetLagMs: 100,
+          adaptToBackendRate: false,
+          minCharsPerFrame: 4,
+          maxCharsPerFrame: 20
+        });
+      }),
+      result = _renderHook2.result;
+    expect(result.current).toBe('');
+    act(function () {
+      jest.advanceTimersByTime(200);
+    });
+    expect(result.current.length).toBeGreaterThan(0);
+    expect('Hello there'.startsWith(result.current)).toBe(true);
+  });
+  it('completes immediately when enabled switches to false', function () {
+    var _renderHook3 = renderHook(function (_ref) {
+        var enabled = _ref.enabled,
+          text = _ref.text;
+        return useSmoothStreamText(text, {
+          enabled: enabled,
+          warmupMs: 0
+        });
+      }, {
+        initialProps: {
+          enabled: true,
+          text: 'Streaming text'
+        }
+      }),
+      result = _renderHook3.result,
+      rerender = _renderHook3.rerender;
+    rerender({
+      enabled: false,
+      text: 'Streaming text'
+    });
+    expect(result.current).toBe('Streaming text');
+  });
+  it('respects snapToWordBoundary when advancing characters', function () {
+    var _renderHook4 = renderHook(function () {
+        return useSmoothStreamText('hello world', {
+          enabled: true,
+          warmupMs: 0,
+          targetLagMs: 50,
+          snapToWordBoundary: true,
+          adaptToBackendRate: false,
+          minCharsPerFrame: 3,
+          maxCharsPerFrame: 3
+        });
+      }),
+      result = _renderHook4.result;
+    act(function () {
+      jest.advanceTimersByTime(200);
+    });
+    expect(result.current === '' || result.current.endsWith(' ') || result.current === 'hello world').toBe(true);
+  });
+  it('resets displayed text when the target shrinks', function () {
+    var _renderHook5 = renderHook(function (_ref2) {
+        var text = _ref2.text;
+        return useSmoothStreamText(text, {
+          enabled: true,
+          warmupMs: 0
+        });
+      }, {
+        initialProps: {
+          text: 'long text here'
+        }
+      }),
+      result = _renderHook5.result,
+      rerender = _renderHook5.rerender;
+    act(function () {
+      jest.advanceTimersByTime(500);
+    });
+    rerender({
+      text: 'sh'
+    });
+    expect(result.current.length).toBeLessThanOrEqual(2);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useSnackBarManager/useSnackBarManager.spec.js

@@ -0,0 +1,33 @@
+import { renderHook } from '@testing-library/react';
+import { useSnackBarManager } from './useSnackBarManager';
+describe('useSnackBarManager', function () {
+  it('dispatches success, error and info snackbar events', function () {
+    var handler = jest.fn();
+    document.addEventListener('snackbar-event', handler);
+    var _renderHook = renderHook(function () {
+        return useSnackBarManager();
+      }),
+      result = _renderHook.result;
+    result.current.handleSnackbarSuccess('ok');
+    result.current.handleSnackbarError('fail');
+    result.current.handleSnackbarInfo('info');
+    expect(handler).toHaveBeenCalledTimes(3);
+    expect(handler.mock.calls[0][0].detail).toEqual({
+      show: true,
+      severity: 'success',
+      message: 'ok'
+    });
+    expect(handler.mock.calls[1][0].detail).toEqual({
+      show: true,
+      severity: 'error',
+      message: 'fail'
+    });
+    expect(handler.mock.calls[2][0].detail).toEqual({
+      show: true,
+      severity: 'info',
+      message: 'info'
+    });
+    document.removeEventListener('snackbar-event', handler);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useStreamResponse.spec.js

@@ -0,0 +1,199 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { useStreamResponse } from './useStreamResponse';
+var encode = function encode(text) {
+  return new TextEncoder().encode(text);
+};
+var createReadableStream = function createReadableStream(chunks) {
+  var index = 0;
+  return {
+    getReader: function getReader() {
+      return {
+        read: function read() {
+          if (index >= chunks.length) {
+            return Promise.resolve({
+              done: true,
+              value: undefined
+            });
+          }
+          var value = chunks[index];
+          index += 1;
+          return Promise.resolve({
+            done: false,
+            value: value
+          });
+        }
+      };
+    }
+  };
+};
+describe('useStreamResponse', function () {
+  it('sets loading and forwards decoded stream chunks to setData', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var setData, setError, setLoading, onFinishStream, _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          setData = jest.fn();
+          setError = jest.fn();
+          setLoading = jest.fn();
+          onFinishStream = jest.fn();
+          _renderHook = renderHook(function () {
+            return useStreamResponse({
+              setData: setData,
+              setError: setError,
+              setLoading: setLoading,
+              onFinishStream: onFinishStream
+            });
+          }), result = _renderHook.result;
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.handleStream({
+                    body: createReadableStream([encode('data: hello')])
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(setLoading).toHaveBeenCalledWith(true);
+          expect(setData).toHaveBeenCalledWith('hello');
+          expect(setLoading).toHaveBeenCalledWith(false);
+          expect(onFinishStream).toHaveBeenCalled();
+          expect(setError).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('strips stream terminators from chunks', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var setData, _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          setData = jest.fn();
+          _renderHook2 = renderHook(function () {
+            return useStreamResponse({
+              setData: setData,
+              setError: jest.fn(),
+              setLoading: jest.fn(),
+              onFinishStream: jest.fn()
+            });
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.handleStream({
+                    body: createReadableStream([encode('event: enddata: [DONE]data: line one')])
+                  });
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(setData).toHaveBeenCalledWith('line one');
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('returns early when the response has no body', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var setLoading, _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          setLoading = jest.fn();
+          _renderHook3 = renderHook(function () {
+            return useStreamResponse({
+              setData: jest.fn(),
+              setError: jest.fn(),
+              setLoading: setLoading,
+              onFinishStream: jest.fn()
+            });
+          }), result = _renderHook3.result;
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.handleStream({
+                    body: null
+                  });
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          expect(setLoading).toHaveBeenCalledWith(true);
+          expect(setLoading).not.toHaveBeenCalledWith(false);
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('sets error state when reading the stream fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var setError, setLoading, _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          setError = jest.fn();
+          setLoading = jest.fn();
+          _renderHook4 = renderHook(function () {
+            return useStreamResponse({
+              setData: jest.fn(),
+              setError: setError,
+              setLoading: setLoading,
+              onFinishStream: jest.fn()
+            });
+          }), result = _renderHook4.result;
+          _context8.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+            return _regeneratorRuntime.wrap(function (_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 1;
+                  return result.current.handleStream({
+                    body: {
+                      getReader: function getReader() {
+                        return {
+                          read: function read() {
+                            return Promise.reject(new Error('broken pipe'));
+                          }
+                        };
+                      }
+                    }
+                  });
+                case 1:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7);
+          })));
+        case 1:
+          expect(setError).toHaveBeenCalledWith(true);
+          expect(setLoading).toHaveBeenCalledWith(false);
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","useStreamResponse","encode","text","TextEncoder","createReadableStream","chunks","index","getReader","read","length","Promise","resolve","done","value","undefined","describe","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","setData","setError","setLoading","onFinishStream","_renderHook","result","wrap","_context2","prev","next","jest","fn","_callee","_context","current","handleStream","body","stop","expect","toHaveBeenCalledWith","toHaveBeenCalled","not","_callee4","_renderHook2","_context4","_callee3","_context3","_callee6","_renderHook3","_context6","_callee5","_context5","_callee8","_renderHook4","_context8","_callee7","_context7","reject","Error"],"sources":["../../src/hooks/useStreamResponse.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { useStreamResponse } from './useStreamResponse'\n\nconst encode = (text: string) => new TextEncoder().encode(text)\n\nconst createReadableStream = (chunks: Uint8Array[]) => {\n  let index = 0\n  return {\n    getReader: () => ({\n      read: () => {\n        if (index >= chunks.length) {\n          return Promise.resolve({ done: true, value: undefined })\n        }\n        const value = chunks[index]\n        index += 1\n        return Promise.resolve({ done: false, value })\n      },\n    }),\n  }\n}\n\ndescribe('useStreamResponse', () => {\n  it('sets loading and forwards decoded stream chunks to setData', async () => {\n    const setData = jest.fn()\n    const setError = jest.fn()\n    const setLoading = jest.fn()\n    const onFinishStream = jest.fn()\n\n    const { result } = renderHook(() => useStreamResponse({ setData, setError, setLoading, onFinishStream }))\n\n    await act(async () => {\n      await result.current.handleStream({\n        body: createReadableStream([encode('data: hello')]),\n      })\n    })\n\n    expect(setLoading).toHaveBeenCalledWith(true)\n    expect(setData).toHaveBeenCalledWith('hello')\n    expect(setLoading).toHaveBeenCalledWith(false)\n    expect(onFinishStream).toHaveBeenCalled()\n    expect(setError).not.toHaveBeenCalled()\n  })\n\n  it('strips stream terminators from chunks', async () => {\n    const setData = jest.fn()\n    const { result } = renderHook(() =>\n      useStreamResponse({\n        setData,\n        setError: jest.fn(),\n        setLoading: jest.fn(),\n        onFinishStream: jest.fn(),\n      })\n    )\n\n    await act(async () => {\n      await result.current.handleStream({\n        body: createReadableStream([encode('event: enddata: [DONE]data: line one')]),\n      })\n    })\n\n    expect(setData).toHaveBeenCalledWith('line one')\n  })\n\n  it('returns early when the response has no body', async () => {\n    const setLoading = jest.fn()\n    const { result } = renderHook(() =>\n      useStreamResponse({\n        setData: jest.fn(),\n        setError: jest.fn(),\n        setLoading,\n        onFinishStream: jest.fn(),\n      })\n    )\n\n    await act(async () => {\n      await result.current.handleStream({ body: null })\n    })\n\n    expect(setLoading).toHaveBeenCalledWith(true)\n    expect(setLoading).not.toHaveBeenCalledWith(false)\n  })\n\n  it('sets error state when reading the stream fails', async () => {\n    const setError = jest.fn()\n    const setLoading = jest.fn()\n    const { result } = renderHook(() =>\n      useStreamResponse({\n        setData: jest.fn(),\n        setError,\n        setLoading,\n        onFinishStream: jest.fn(),\n      })\n    )\n\n    await act(async () => {\n      await result.current.handleStream({\n        body: {\n          getReader: () => ({\n            read: () => Promise.reject(new Error('broken pipe')),\n          }),\n        },\n      })\n    })\n\n    expect(setError).toHaveBeenCalledWith(true)\n    expect(setLoading).toHaveBeenCalledWith(false)\n  })\n})\n"],"mappings":";;AAAA,SAASA,GAAG,EAAEC,UAAU,QAAQ,wBAAwB;AACxD,SAASC,iBAAiB,QAAQ,qBAAqB;AAEvD,IAAMC,MAAM,GAAG,SAATA,MAAMA,CAAIC,IAAY;EAAA,OAAK,IAAIC,WAAW,CAAC,CAAC,CAACF,MAAM,CAACC,IAAI,CAAC;AAAA;AAE/D,IAAME,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAAIC,MAAoB,EAAK;EACrD,IAAIC,KAAK,GAAG,CAAC;EACb,OAAO;IACLC,SAAS,EAAE,SAAXA,SAASA,CAAA;MAAA,OAAS;QAChBC,IAAI,EAAE,SAANA,IAAIA,CAAA,EAAQ;UACV,IAAIF,KAAK,IAAID,MAAM,CAACI,MAAM,EAAE;YAC1B,OAAOC,OAAO,CAACC,OAAO,CAAC;cAAEC,IAAI,EAAE,IAAI;cAAEC,KAAK,EAAEC;YAAU,CAAC,CAAC;UAC1D;UACA,IAAMD,KAAK,GAAGR,MAAM,CAACC,KAAK,CAAC;UAC3BA,KAAK,IAAI,CAAC;UACV,OAAOI,OAAO,CAACC,OAAO,CAAC;YAAEC,IAAI,EAAE,KAAK;YAAEC,KAAK,EAALA;UAAM,CAAC,CAAC;QAChD;MACF,CAAC;IAAA;EACH,CAAC;AACH,CAAC;AAEDE,QAAQ,CAAC,mBAAmB,EAAE,YAAM;EAClCC,EAAE,CAAC,4DAA4D,eAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAC,SAAA;IAAA,IAAAC,OAAA,EAAAC,QAAA,EAAAC,UAAA,EAAAC,cAAA,EAAAC,WAAA,EAAAC,MAAA;IAAA,OAAAR,mBAAA,CAAAS,IAAA,WAAAC,SAAA;MAAA,kBAAAA,SAAA,CAAAC,IAAA,GAAAD,SAAA,CAAAE,IAAA;QAAA;UACzDT,OAAO,GAAGU,IAAI,CAACC,EAAE,CAAC,CAAC;UACnBV,QAAQ,GAAGS,IAAI,CAACC,EAAE,CAAC,CAAC;UACpBT,UAAU,GAAGQ,IAAI,CAACC,EAAE,CAAC,CAAC;UACtBR,cAAc,GAAGO,IAAI,CAACC,EAAE,CAAC,CAAC;UAAAP,WAAA,GAEb1B,UAAU,CAAC;YAAA,OAAMC,iBAAiB,CAAC;cAAEqB,OAAO,EAAPA,OAAO;cAAEC,QAAQ,EAARA,QAAQ;cAAEC,UAAU,EAAVA,UAAU;cAAEC,cAAc,EAAdA;YAAe,CAAC,CAAC;UAAA,EAAC,EAAjGE,MAAM,GAAAD,WAAA,CAANC,MAAM;UAAAE,SAAA,CAAAE,IAAA;UAAA,OAERhC,GAAG,cAAAmB,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAc,QAAA;YAAA,OAAAf,mBAAA,CAAAS,IAAA,WAAAO,QAAA;cAAA,kBAAAA,QAAA,CAAAL,IAAA,GAAAK,QAAA,CAAAJ,IAAA;gBAAA;kBAAAI,QAAA,CAAAJ,IAAA;kBAAA,OACFJ,MAAM,CAACS,OAAO,CAACC,YAAY,CAAC;oBAChCC,IAAI,EAAEjC,oBAAoB,CAAC,CAACH,MAAM,CAAC,aAAa,CAAC,CAAC;kBACpD,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAiC,QAAA,CAAAI,IAAA;cAAA;YAAA,GAAAL,OAAA;UAAA,CACH,GAAC;QAAA;UAEFM,MAAM,CAAChB,UAAU,CAAC,CAACiB,oBAAoB,CAAC,IAAI,CAAC;UAC7CD,MAAM,CAAClB,OAAO,CAAC,CAACmB,oBAAoB,CAAC,OAAO,CAAC;UAC7CD,MAAM,CAAChB,UAAU,CAAC,CAACiB,oBAAoB,CAAC,KAAK,CAAC;UAC9CD,MAAM,CAACf,cAAc,CAAC,CAACiB,gBAAgB,CAAC,CAAC;UACzCF,MAAM,CAACjB,QAAQ,CAAC,CAACoB,GAAG,CAACD,gBAAgB,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAb,SAAA,CAAAU,IAAA;MAAA;IAAA,GAAAlB,QAAA;EAAA,CACxC,GAAC;EAEFJ,EAAE,CAAC,uCAAuC,eAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAwB,SAAA;IAAA,IAAAtB,OAAA,EAAAuB,YAAA,EAAAlB,MAAA;IAAA,OAAAR,mBAAA,CAAAS,IAAA,WAAAkB,SAAA;MAAA,kBAAAA,SAAA,CAAAhB,IAAA,GAAAgB,SAAA,CAAAf,IAAA;QAAA;UACpCT,OAAO,GAAGU,IAAI,CAACC,EAAE,CAAC,CAAC;UAAAY,YAAA,GACN7C,UAAU,CAAC;YAAA,OAC5BC,iBAAiB,CAAC;cAChBqB,OAAO,EAAPA,OAAO;cACPC,QAAQ,EAAES,IAAI,CAACC,EAAE,CAAC,CAAC;cACnBT,UAAU,EAAEQ,IAAI,CAACC,EAAE,CAAC,CAAC;cACrBR,cAAc,EAAEO,IAAI,CAACC,EAAE,CAAC;YAC1B,CAAC,CAAC;UAAA,CACJ,CAAC,EAPON,MAAM,GAAAkB,YAAA,CAANlB,MAAM;UAAAmB,SAAA,CAAAf,IAAA;UAAA,OASRhC,GAAG,cAAAmB,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAA2B,SAAA;YAAA,OAAA5B,mBAAA,CAAAS,IAAA,WAAAoB,SAAA;cAAA,kBAAAA,SAAA,CAAAlB,IAAA,GAAAkB,SAAA,CAAAjB,IAAA;gBAAA;kBAAAiB,SAAA,CAAAjB,IAAA;kBAAA,OACFJ,MAAM,CAACS,OAAO,CAACC,YAAY,CAAC;oBAChCC,IAAI,EAAEjC,oBAAoB,CAAC,CAACH,MAAM,CAAC,sCAAsC,CAAC,CAAC;kBAC7E,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAA8C,SAAA,CAAAT,IAAA;cAAA;YAAA,GAAAQ,QAAA;UAAA,CACH,GAAC;QAAA;UAEFP,MAAM,CAAClB,OAAO,CAAC,CAACmB,oBAAoB,CAAC,UAAU,CAAC;QAAA;QAAA;UAAA,OAAAK,SAAA,CAAAP,IAAA;MAAA;IAAA,GAAAK,QAAA;EAAA,CACjD,GAAC;EAEF3B,EAAE,CAAC,6CAA6C,eAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA6B,SAAA;IAAA,IAAAzB,UAAA,EAAA0B,YAAA,EAAAvB,MAAA;IAAA,OAAAR,mBAAA,CAAAS,IAAA,WAAAuB,SAAA;MAAA,kBAAAA,SAAA,CAAArB,IAAA,GAAAqB,SAAA,CAAApB,IAAA;QAAA;UAC1CP,UAAU,GAAGQ,IAAI,CAACC,EAAE,CAAC,CAAC;UAAAiB,YAAA,GACTlD,UAAU,CAAC;YAAA,OAC5BC,iBAAiB,CAAC;cAChBqB,OAAO,EAAEU,IAAI,CAACC,EAAE,CAAC,CAAC;cAClBV,QAAQ,EAAES,IAAI,CAACC,EAAE,CAAC,CAAC;cACnBT,UAAU,EAAVA,UAAU;cACVC,cAAc,EAAEO,IAAI,CAACC,EAAE,CAAC;YAC1B,CAAC,CAAC;UAAA,CACJ,CAAC,EAPON,MAAM,GAAAuB,YAAA,CAANvB,MAAM;UAAAwB,SAAA,CAAApB,IAAA;UAAA,OASRhC,GAAG,cAAAmB,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAgC,SAAA;YAAA,OAAAjC,mBAAA,CAAAS,IAAA,WAAAyB,SAAA;cAAA,kBAAAA,SAAA,CAAAvB,IAAA,GAAAuB,SAAA,CAAAtB,IAAA;gBAAA;kBAAAsB,SAAA,CAAAtB,IAAA;kBAAA,OACFJ,MAAM,CAACS,OAAO,CAACC,YAAY,CAAC;oBAAEC,IAAI,EAAE;kBAAK,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAe,SAAA,CAAAd,IAAA;cAAA;YAAA,GAAAa,QAAA;UAAA,CAClD,GAAC;QAAA;UAEFZ,MAAM,CAAChB,UAAU,CAAC,CAACiB,oBAAoB,CAAC,IAAI,CAAC;UAC7CD,MAAM,CAAChB,UAAU,CAAC,CAACmB,GAAG,CAACF,oBAAoB,CAAC,KAAK,CAAC;QAAA;QAAA;UAAA,OAAAU,SAAA,CAAAZ,IAAA;MAAA;IAAA,GAAAU,QAAA;EAAA,CACnD,GAAC;EAEFhC,EAAE,CAAC,gDAAgD,eAAAC,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAkC,SAAA;IAAA,IAAA/B,QAAA,EAAAC,UAAA,EAAA+B,YAAA,EAAA5B,MAAA;IAAA,OAAAR,mBAAA,CAAAS,IAAA,WAAA4B,SAAA;MAAA,kBAAAA,SAAA,CAAA1B,IAAA,GAAA0B,SAAA,CAAAzB,IAAA;QAAA;UAC7CR,QAAQ,GAAGS,IAAI,CAACC,EAAE,CAAC,CAAC;UACpBT,UAAU,GAAGQ,IAAI,CAACC,EAAE,CAAC,CAAC;UAAAsB,YAAA,GACTvD,UAAU,CAAC;YAAA,OAC5BC,iBAAiB,CAAC;cAChBqB,OAAO,EAAEU,IAAI,CAACC,EAAE,CAAC,CAAC;cAClBV,QAAQ,EAARA,QAAQ;cACRC,UAAU,EAAVA,UAAU;cACVC,cAAc,EAAEO,IAAI,CAACC,EAAE,CAAC;YAC1B,CAAC,CAAC;UAAA,CACJ,CAAC,EAPON,MAAM,GAAA4B,YAAA,CAAN5B,MAAM;UAAA6B,SAAA,CAAAzB,IAAA;UAAA,OASRhC,GAAG,cAAAmB,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAC,SAAAqC,SAAA;YAAA,OAAAtC,mBAAA,CAAAS,IAAA,WAAA8B,SAAA;cAAA,kBAAAA,SAAA,CAAA5B,IAAA,GAAA4B,SAAA,CAAA3B,IAAA;gBAAA;kBAAA2B,SAAA,CAAA3B,IAAA;kBAAA,OACFJ,MAAM,CAACS,OAAO,CAACC,YAAY,CAAC;oBAChCC,IAAI,EAAE;sBACJ9B,SAAS,EAAE,SAAXA,SAASA,CAAA;wBAAA,OAAS;0BAChBC,IAAI,EAAE,SAANA,IAAIA,CAAA;4BAAA,OAAQE,OAAO,CAACgD,MAAM,CAAC,IAAIC,KAAK,CAAC,aAAa,CAAC,CAAC;0BAAA;wBACtD,CAAC;sBAAA;oBACH;kBACF,CAAC,CAAC;gBAAA;gBAAA;kBAAA,OAAAF,SAAA,CAAAnB,IAAA;cAAA;YAAA,GAAAkB,QAAA;UAAA,CACH,GAAC;QAAA;UAEFjB,MAAM,CAACjB,QAAQ,CAAC,CAACkB,oBAAoB,CAAC,IAAI,CAAC;UAC3CD,MAAM,CAAChB,UAAU,CAAC,CAACiB,oBAAoB,CAAC,KAAK,CAAC;QAAA;QAAA;UAAA,OAAAe,SAAA,CAAAjB,IAAA;MAAA;IAAA,GAAAe,QAAA;EAAA,CAC/C,GAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/hooks/useT.spec.js

@@ -0,0 +1,20 @@
+import { renderHook } from '@testing-library/react';
+import { useT, useTWithSection } from './useT';
+describe('useT', function () {
+  it('returns the mocked translator', function () {
+    var _renderHook = renderHook(function () {
+        return useT();
+      }),
+      result = _renderHook.result;
+    expect(result.current.t('chat.send')).toBe('chat.send');
+    expect(result.current.i18n.language).toBe('es');
+  });
+  it('returns a translator for a section', function () {
+    var _renderHook2 = renderHook(function () {
+        return useTWithSection('agents');
+      }),
+      result = _renderHook2.result;
+    expect(result.current('agents.title')).toBe('agents.title');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJyZW5kZXJIb29rIiwidXNlVCIsInVzZVRXaXRoU2VjdGlvbiIsImRlc2NyaWJlIiwiaXQiLCJfcmVuZGVySG9vayIsInJlc3VsdCIsImV4cGVjdCIsImN1cnJlbnQiLCJ0IiwidG9CZSIsImkxOG4iLCJsYW5ndWFnZSIsIl9yZW5kZXJIb29rMiJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ob29rcy91c2VULnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmVuZGVySG9vayB9IGZyb20gJ0B0ZXN0aW5nLWxpYnJhcnkvcmVhY3QnXG5pbXBvcnQgeyB1c2VULCB1c2VUV2l0aFNlY3Rpb24gfSBmcm9tICcuL3VzZVQnXG5cbmRlc2NyaWJlKCd1c2VUJywgKCkgPT4ge1xuICBpdCgncmV0dXJucyB0aGUgbW9ja2VkIHRyYW5zbGF0b3InLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlVCgpKVxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC50KCdjaGF0LnNlbmQnKSkudG9CZSgnY2hhdC5zZW5kJylcbiAgICBleHBlY3QocmVzdWx0LmN1cnJlbnQuaTE4bi5sYW5ndWFnZSkudG9CZSgnZXMnKVxuICB9KVxuXG4gIGl0KCdyZXR1cm5zIGEgdHJhbnNsYXRvciBmb3IgYSBzZWN0aW9uJywgKCkgPT4ge1xuICAgIGNvbnN0IHsgcmVzdWx0IH0gPSByZW5kZXJIb29rKCgpID0+IHVzZVRXaXRoU2VjdGlvbignYWdlbnRzJykpXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50KCdhZ2VudHMudGl0bGUnKSkudG9CZSgnYWdlbnRzLnRpdGxlJylcbiAgfSlcbn0pXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFVBQVUsUUFBUSx3QkFBd0I7QUFDbkQsU0FBU0MsSUFBSSxFQUFFQyxlQUFlLFFBQVEsUUFBUTtBQUU5Q0MsUUFBUSxDQUFDLE1BQU0sRUFBRSxZQUFNO0VBQ3JCQyxFQUFFLENBQUMsK0JBQStCLEVBQUUsWUFBTTtJQUN4QyxJQUFBQyxXQUFBLEdBQW1CTCxVQUFVLENBQUM7UUFBQSxPQUFNQyxJQUFJLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBbkNLLE1BQU0sR0FBQUQsV0FBQSxDQUFOQyxNQUFNO0lBQ2RDLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUNDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDQyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQ3ZESCxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDRyxJQUFJLENBQUNDLFFBQVEsQ0FBQyxDQUFDRixJQUFJLENBQUMsSUFBSSxDQUFDO0VBQ2pELENBQUMsQ0FBQztFQUVGTixFQUFFLENBQUMsb0NBQW9DLEVBQUUsWUFBTTtJQUM3QyxJQUFBUyxZQUFBLEdBQW1CYixVQUFVLENBQUM7UUFBQSxPQUFNRSxlQUFlLENBQUMsUUFBUSxDQUFDO01BQUEsRUFBQztNQUF0REksTUFBTSxHQUFBTyxZQUFBLENBQU5QLE1BQU07SUFDZEMsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDRSxJQUFJLENBQUMsY0FBYyxDQUFDO0VBQzdELENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/hooks/useToggle.spec.js

@@ -0,0 +1,33 @@
+import { act, renderHook } from '@testing-library/react';
+import { useToggle } from './useToggle';
+describe('useToggle', function () {
+  it('starts as false by default', function () {
+    var _renderHook = renderHook(function () {
+        return useToggle();
+      }),
+      result = _renderHook.result;
+    expect(result.current[0]).toBe(false);
+  });
+  it('starts with the given default value', function () {
+    var _renderHook2 = renderHook(function () {
+        return useToggle(true);
+      }),
+      result = _renderHook2.result;
+    expect(result.current[0]).toBe(true);
+  });
+  it('toggles and turns off', function () {
+    var _renderHook3 = renderHook(function () {
+        return useToggle();
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current[1]();
+    });
+    expect(result.current[0]).toBe(true);
+    act(function () {
+      result.current[2]();
+    });
+    expect(result.current[0]).toBe(false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useToggleFavorite/useToggleFavorite.spec.js

@@ -0,0 +1,171 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { toggleFavoriteAgent } from '../../services/maia/Agents/toggleFavorite';
+import { useToggleFavorite } from './useToggleFavorite';
+jest.mock('../../services/maia/Agents/toggleFavorite', function () {
+  return {
+    toggleFavoriteAgent: jest.fn()
+  };
+});
+var handleSnackbarSuccess = jest.fn();
+var handleSnackbarError = jest.fn();
+jest.mock('../useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarSuccess: handleSnackbarSuccess,
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+var toggleFavoriteAgentMock = toggleFavoriteAgent;
+var updatedAgent = {
+  id: '1',
+  name: 'MAIA',
+  is_favorite: true
+};
+describe('useToggleFavorite', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    toggleFavoriteAgentMock.mockResolvedValue(updatedAgent);
+  });
+  it('calls onSuccess and shows the added snackbar when favoriting', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var onSuccess, _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onSuccess = jest.fn();
+          _renderHook = renderHook(function () {
+            return useToggleFavorite();
+          }), result = _renderHook.result;
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.toggleFavorite('1', onSuccess, undefined, false);
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(toggleFavoriteAgentMock).toHaveBeenCalledWith('1');
+          expect(onSuccess).toHaveBeenCalledWith(updatedAgent);
+          expect(handleSnackbarSuccess).toHaveBeenCalled();
+          expect(handleSnackbarError).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('shows the removed snackbar when unfavoriting', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useToggleFavorite();
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.toggleFavorite('1', jest.fn(), undefined, true);
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(handleSnackbarSuccess).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('handles API errors and invokes onError', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var onError, _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          toggleFavoriteAgentMock.mockRejectedValue(new Error('Network down'));
+          onError = jest.fn();
+          _renderHook3 = renderHook(function () {
+            return useToggleFavorite();
+          }), result = _renderHook3.result;
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return expect(result.current.toggleFavorite('1', undefined, onError, false)).rejects.toThrow('Network down');
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          expect(result.current.error).toBe('Network down');
+          expect(handleSnackbarError).toHaveBeenCalled();
+          expect(onError).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('resetError clears the error state', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          toggleFavoriteAgentMock.mockRejectedValue(new Error('fail'));
+          _renderHook4 = renderHook(function () {
+            return useToggleFavorite();
+          }), result = _renderHook4.result;
+          _context8.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+            var _t;
+            return _regeneratorRuntime.wrap(function (_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.prev = 0;
+                  _context7.next = 1;
+                  return result.current.toggleFavorite('1');
+                case 1:
+                  _context7.next = 3;
+                  break;
+                case 2:
+                  _context7.prev = 2;
+                  _t = _context7["catch"](0);
+                case 3:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7, null, [[0, 2]]);
+          })));
+        case 1:
+          act(function () {
+            result.current.resetError();
+          });
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","toggleFavoriteAgent","useToggleFavorite","jest","mock","fn","handleSnackbarSuccess","handleSnackbarError","useSnackBarManager","toggleFavoriteAgentMock","updatedAgent","id","name","is_favorite","describe","beforeEach","clearAllMocks","mockResolvedValue","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","onSuccess","_renderHook","result","wrap","_context2","prev","next","_callee","_context","current","toggleFavorite","undefined","stop","expect","toHaveBeenCalledWith","toHaveBeenCalled","not","_callee4","_renderHook2","_context4","_callee3","_context3","_callee6","onError","_renderHook3","_context6","mockRejectedValue","Error","_callee5","_context5","rejects","toThrow","error","toBe","_callee8","_renderHook4","_context8","_callee7","_t","_context7","resetError","toBeNull"],"sources":["../../../src/hooks/useToggleFavorite/useToggleFavorite.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { toggleFavoriteAgent } from '../../services/maia/Agents/toggleFavorite'\nimport { useToggleFavorite } from './useToggleFavorite'\n\njest.mock('../../services/maia/Agents/toggleFavorite', () => ({\n  toggleFavoriteAgent: jest.fn(),\n}))\n\nconst handleSnackbarSuccess = jest.fn()\nconst handleSnackbarError = jest.fn()\n\njest.mock('../useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarSuccess, handleSnackbarError }),\n}))\n\nconst toggleFavoriteAgentMock = toggleFavoriteAgent as jest.MockedFunction<typeof toggleFavoriteAgent>\n\nconst updatedAgent = { id: '1', name: 'MAIA', is_favorite: true } as const\n\ndescribe('useToggleFavorite', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    toggleFavoriteAgentMock.mockResolvedValue(updatedAgent as never)\n  })\n\n  it('calls onSuccess and shows the added snackbar when favoriting', async () => {\n    const onSuccess = jest.fn()\n    const { result } = renderHook(() => useToggleFavorite())\n\n    await act(async () => {\n      await result.current.toggleFavorite('1', onSuccess, undefined, false)\n    })\n\n    expect(toggleFavoriteAgentMock).toHaveBeenCalledWith('1')\n    expect(onSuccess).toHaveBeenCalledWith(updatedAgent)\n    expect(handleSnackbarSuccess).toHaveBeenCalled()\n    expect(handleSnackbarError).not.toHaveBeenCalled()\n  })\n\n  it('shows the removed snackbar when unfavoriting', async () => {\n    const { result } = renderHook(() => useToggleFavorite())\n\n    await act(async () => {\n      await result.current.toggleFavorite('1', jest.fn(), undefined, true)\n    })\n\n    expect(handleSnackbarSuccess).toHaveBeenCalled()\n  })\n\n  it('handles API errors and invokes onError', async () => {\n    toggleFavoriteAgentMock.mockRejectedValue(new Error('Network down'))\n    const onError = jest.fn()\n    const { result } = renderHook(() => useToggleFavorite())\n\n    await act(async () => {\n      await expect(result.current.toggleFavorite('1', undefined, onError, false)).rejects.toThrow('Network down')\n    })\n\n    expect(result.current.error).toBe('Network down')\n    expect(handleSnackbarError).toHaveBeenCalled()\n    expect(onError).toHaveBeenCalled()\n  })\n\n  it('resetError clears the error state', async () => {\n    toggleFavoriteAgentMock.mockRejectedValue(new Error('fail'))\n    const { result } = renderHook(() => useToggleFavorite())\n\n    await act(async () => {\n      try {\n        await result.current.toggleFavorite('1')\n      } catch {\n        // expected\n      }\n    })\n\n    act(() => {\n      result.current.resetError()\n    })\n\n    expect(result.current.error).toBeNull()\n  })\n})\n"],"mappings":"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","ignoreList":[]}