@projectcor/maia-components 2.44.4 → 2.44.5-0

package/lib/hooks/useSlashCommands.spec.js

@@ -0,0 +1,139 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { getSlashCommands } from '../services/maia/Actions/getSlashCommands';
+import { useSlashCommands } from './useSlashCommands';
+jest.mock('../services/maia/Actions/getSlashCommands', function () {
+  return {
+    getSlashCommands: jest.fn()
+  };
+});
+var getSlashCommandsMock = getSlashCommands;
+var actions = [{
+  id: '1',
+  name: 'Summarize',
+  entity_types: ['task']
+}, {
+  id: '2',
+  name: 'Plan',
+  entity_types: ['planner']
+}];
+describe('useSlashCommands', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    window.MAIA_HOUR_AGENT_FEATURE_ACCESS = false;
+    getSlashCommandsMock.mockResolvedValue({
+      data: actions
+    });
+  });
+  it('loads commands when agentId is provided', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useSlashCommands('agent-1');
+          }), result = _renderHook.result;
+          _context.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loading).toBe(false);
+          });
+        case 1:
+          expect(getSlashCommandsMock).toHaveBeenCalledWith(expect.objectContaining({
+            agentId: 'agent-1'
+          }));
+          expect(result.current.commands).toHaveLength(1);
+          expect(result.current.commands[0].name).toBe('Summarize');
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('keeps planner commands when hour agent feature is enabled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          window.MAIA_HOUR_AGENT_FEATURE_ACCESS = true;
+          _renderHook2 = renderHook(function () {
+            return useSlashCommands('agent-1');
+          }), result = _renderHook2.result;
+          _context2.next = 1;
+          return waitFor(function () {
+            return expect(result.current.loading).toBe(false);
+          });
+        case 1:
+          expect(result.current.commands).toHaveLength(2);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('does not fetch when agentId is missing', function () {
+    var _renderHook3 = renderHook(function () {
+        return useSlashCommands(undefined);
+      }),
+      result = _renderHook3.result;
+    expect(getSlashCommandsMock).not.toHaveBeenCalled();
+    expect(result.current.commands).toEqual([]);
+  });
+  it('sets error when the response shape is invalid', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          getSlashCommandsMock.mockResolvedValue({
+            data: null
+          });
+          _renderHook4 = renderHook(function () {
+            return useSlashCommands('agent-1');
+          }), result = _renderHook4.result;
+          _context3.next = 1;
+          return waitFor(function () {
+            return expect(result.current.error).toBeTruthy();
+          });
+        case 1:
+          expect(result.current.error).toBe('Invalid response format from server');
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('allows manual refetch via handleGetSlashCommands', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _renderHook5, result;
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _renderHook5 = renderHook(function () {
+            return useSlashCommands(undefined);
+          }), result = _renderHook5.result;
+          _context5.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+            return _regeneratorRuntime.wrap(function (_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  _context4.next = 1;
+                  return result.current.handleGetSlashCommands('agent-9');
+                case 1:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          })));
+        case 1:
+          expect(getSlashCommandsMock).toHaveBeenCalledWith(expect.objectContaining({
+            agentId: 'agent-9'
+          }));
+          expect(result.current.commands).toHaveLength(1);
+        case 2:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","waitFor","getSlashCommands","useSlashCommands","jest","mock","fn","getSlashCommandsMock","actions","id","name","entity_types","describe","beforeEach","clearAllMocks","window","MAIA_HOUR_AGENT_FEATURE_ACCESS","mockResolvedValue","data","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_renderHook","result","wrap","_context","prev","next","expect","current","loading","toBe","toHaveBeenCalledWith","objectContaining","agentId","commands","toHaveLength","error","toBeNull","stop","_callee2","_renderHook2","_context2","_renderHook3","undefined","not","toHaveBeenCalled","toEqual","_callee3","_renderHook4","_context3","toBeTruthy","_callee5","_renderHook5","_context5","_callee4","_context4","handleGetSlashCommands"],"sources":["../../src/hooks/useSlashCommands.spec.ts"],"sourcesContent":["import { act, renderHook, waitFor } from '@testing-library/react'\nimport { getSlashCommands } from '../services/maia/Actions/getSlashCommands'\nimport { useSlashCommands } from './useSlashCommands'\n\njest.mock('../services/maia/Actions/getSlashCommands', () => ({\n  getSlashCommands: jest.fn(),\n}))\n\nconst getSlashCommandsMock = getSlashCommands as jest.MockedFunction<typeof getSlashCommands>\n\nconst actions = [\n  { id: '1', name: 'Summarize', entity_types: ['task'] },\n  { id: '2', name: 'Plan', entity_types: ['planner'] },\n] as never\n\ndescribe('useSlashCommands', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    window.MAIA_HOUR_AGENT_FEATURE_ACCESS = false\n    getSlashCommandsMock.mockResolvedValue({ data: actions })\n  })\n\n  it('loads commands when agentId is provided', async () => {\n    const { result } = renderHook(() => useSlashCommands('agent-1'))\n\n    await waitFor(() => expect(result.current.loading).toBe(false))\n\n    expect(getSlashCommandsMock).toHaveBeenCalledWith(expect.objectContaining({ agentId: 'agent-1' }))\n    expect(result.current.commands).toHaveLength(1)\n    expect(result.current.commands[0].name).toBe('Summarize')\n    expect(result.current.error).toBeNull()\n  })\n\n  it('keeps planner commands when hour agent feature is enabled', async () => {\n    window.MAIA_HOUR_AGENT_FEATURE_ACCESS = true\n\n    const { result } = renderHook(() => useSlashCommands('agent-1'))\n\n    await waitFor(() => expect(result.current.loading).toBe(false))\n\n    expect(result.current.commands).toHaveLength(2)\n  })\n\n  it('does not fetch when agentId is missing', () => {\n    const { result } = renderHook(() => useSlashCommands(undefined))\n\n    expect(getSlashCommandsMock).not.toHaveBeenCalled()\n    expect(result.current.commands).toEqual([])\n  })\n\n  it('sets error when the response shape is invalid', async () => {\n    getSlashCommandsMock.mockResolvedValue({ data: null } as never)\n\n    const { result } = renderHook(() => useSlashCommands('agent-1'))\n\n    await waitFor(() => expect(result.current.error).toBeTruthy())\n\n    expect(result.current.error).toBe('Invalid response format from server')\n  })\n\n  it('allows manual refetch via handleGetSlashCommands', async () => {\n    const { result } = renderHook(() => useSlashCommands(undefined))\n\n    await act(async () => {\n      await result.current.handleGetSlashCommands('agent-9')\n    })\n\n    expect(getSlashCommandsMock).toHaveBeenCalledWith(expect.objectContaining({ agentId: 'agent-9' }))\n    expect(result.current.commands).toHaveLength(1)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhY3QiLCJyZW5kZXJIb29rIiwidXNlU21vb3RoU3RyZWFtVGV4dCIsImRlc2NyaWJlIiwiYmVmb3JlRWFjaCIsImplc3QiLCJ1c2VGYWtlVGltZXJzIiwiYWZ0ZXJFYWNoIiwidXNlUmVhbFRpbWVycyIsIml0IiwiX3JlbmRlckhvb2siLCJlbmFibGVkIiwicmVzdWx0IiwiZXhwZWN0IiwiY3VycmVudCIsInRvQmUiLCJfcmVuZGVySG9vazIiLCJ3YXJtdXBNcyIsInRhcmdldExhZ01zIiwiYWRhcHRUb0JhY2tlbmRSYXRlIiwibWluQ2hhcnNQZXJGcmFtZSIsIm1heENoYXJzUGVyRnJhbWUiLCJhZHZhbmNlVGltZXJzQnlUaW1lIiwibGVuZ3RoIiwidG9CZUdyZWF0ZXJUaGFuIiwic3RhcnRzV2l0aCIsIl9yZW5kZXJIb29rMyIsIl9yZWYiLCJ0ZXh0IiwiaW5pdGlhbFByb3BzIiwicmVyZW5kZXIiLCJfcmVuZGVySG9vazQiLCJzbmFwVG9Xb3JkQm91bmRhcnkiLCJlbmRzV2l0aCIsIl9yZW5kZXJIb29rNSIsIl9yZWYyIiwidG9CZUxlc3NUaGFuT3JFcXVhbCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ob29rcy91c2VTbW9vdGhTdHJlYW1UZXh0L3VzZVNtb290aFN0cmVhbVRleHQuc3BlYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhY3QsIHJlbmRlckhvb2sgfSBmcm9tICdAdGVzdGluZy1saWJyYXJ5L3JlYWN0J1xuaW1wb3J0IHsgdXNlU21vb3RoU3RyZWFtVGV4dCB9IGZyb20gJy4vdXNlU21vb3RoU3RyZWFtVGV4dCdcblxuZGVzY3JpYmUoJ3VzZVNtb290aFN0cmVhbVRleHQnLCAoKSA9PiB7XG4gIGJlZm9yZUVhY2goKCkgPT4ge1xuICAgIGplc3QudXNlRmFrZVRpbWVycygpXG4gIH0pXG5cbiAgYWZ0ZXJFYWNoKCgpID0+IHtcbiAgICBqZXN0LnVzZVJlYWxUaW1lcnMoKVxuICB9KVxuXG4gIGl0KCdyZXR1cm5zIHRoZSB0YXJnZXQgaW1tZWRpYXRlbHkgd2hlbiBhbmltYXRpb24gaXMgZGlzYWJsZWQnLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlU21vb3RoU3RyZWFtVGV4dCgnaGVsbG8gd29ybGQnLCB7IGVuYWJsZWQ6IGZhbHNlIH0pKVxuXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50KS50b0JlKCdoZWxsbyB3b3JsZCcpXG4gIH0pXG5cbiAgaXQoJ3N0YXJ0cyBlbXB0eSBhbmQgcHJvZ3Jlc3NpdmVseSByZXZlYWxzIHRleHQgd2hpbGUgZW5hYmxlZCcsICgpID0+IHtcbiAgICBjb25zdCB7IHJlc3VsdCB9ID0gcmVuZGVySG9vaygoKSA9PlxuICAgICAgdXNlU21vb3RoU3RyZWFtVGV4dCgnSGVsbG8gdGhlcmUnLCB7XG4gICAgICAgIGVuYWJsZWQ6IHRydWUsXG4gICAgICAgIHdhcm11cE1zOiAwLFxuICAgICAgICB0YXJnZXRMYWdNczogMTAwLFxuICAgICAgICBhZGFwdFRvQmFja2VuZFJhdGU6IGZhbHNlLFxuICAgICAgICBtaW5DaGFyc1BlckZyYW1lOiA0LFxuICAgICAgICBtYXhDaGFyc1BlckZyYW1lOiAyMCxcbiAgICAgIH0pXG4gICAgKVxuXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50KS50b0JlKCcnKVxuXG4gICAgYWN0KCgpID0+IHtcbiAgICAgIGplc3QuYWR2YW5jZVRpbWVyc0J5VGltZSgyMDApXG4gICAgfSlcblxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC5sZW5ndGgpLnRvQmVHcmVhdGVyVGhhbigwKVxuICAgIGV4cGVjdCgnSGVsbG8gdGhlcmUnLnN0YXJ0c1dpdGgocmVzdWx0LmN1cnJlbnQpKS50b0JlKHRydWUpXG4gIH0pXG5cbiAgaXQoJ2NvbXBsZXRlcyBpbW1lZGlhdGVseSB3aGVuIGVuYWJsZWQgc3dpdGNoZXMgdG8gZmFsc2UnLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQsIHJlcmVuZGVyIH0gPSByZW5kZXJIb29rKFxuICAgICAgKHsgZW5hYmxlZCwgdGV4dCB9OiB7IGVuYWJsZWQ6IGJvb2xlYW47IHRleHQ6IHN0cmluZyB9KSA9PiB1c2VTbW9vdGhTdHJlYW1UZXh0KHRleHQsIHsgZW5hYmxlZCwgd2FybXVwTXM6IDAgfSksXG4gICAgICB7IGluaXRpYWxQcm9wczogeyBlbmFibGVkOiB0cnVlLCB0ZXh0OiAnU3RyZWFtaW5nIHRleHQnIH0gfVxuICAgIClcblxuICAgIHJlcmVuZGVyKHsgZW5hYmxlZDogZmFsc2UsIHRleHQ6ICdTdHJlYW1pbmcgdGV4dCcgfSlcblxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudCkudG9CZSgnU3RyZWFtaW5nIHRleHQnKVxuICB9KVxuXG4gIGl0KCdyZXNwZWN0cyBzbmFwVG9Xb3JkQm91bmRhcnkgd2hlbiBhZHZhbmNpbmcgY2hhcmFjdGVycycsICgpID0+IHtcbiAgICBjb25zdCB7IHJlc3VsdCB9ID0gcmVuZGVySG9vaygoKSA9PlxuICAgICAgdXNlU21vb3RoU3RyZWFtVGV4dCgnaGVsbG8gd29ybGQnLCB7XG4gICAgICAgIGVuYWJsZWQ6IHRydWUsXG4gICAgICAgIHdhcm11cE1zOiAwLFxuICAgICAgICB0YXJnZXRMYWdNczogNTAsXG4gICAgICAgIHNuYXBUb1dvcmRCb3VuZGFyeTogdHJ1ZSxcbiAgICAgICAgYWRhcHRUb0JhY2tlbmRSYXRlOiBmYWxzZSxcbiAgICAgICAgbWluQ2hhcnNQZXJGcmFtZTogMyxcbiAgICAgICAgbWF4Q2hhcnNQZXJGcmFtZTogMyxcbiAgICAgIH0pXG4gICAgKVxuXG4gICAgYWN0KCgpID0+IHtcbiAgICAgIGplc3QuYWR2YW5jZVRpbWVyc0J5VGltZSgyMDApXG4gICAgfSlcblxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudCA9PT0gJycgfHwgcmVzdWx0LmN1cnJlbnQuZW5kc1dpdGgoJyAnKSB8fCByZXN1bHQuY3VycmVudCA9PT0gJ2hlbGxvIHdvcmxkJykudG9CZSh0cnVlKVxuICB9KVxuXG4gIGl0KCdyZXNldHMgZGlzcGxheWVkIHRleHQgd2hlbiB0aGUgdGFyZ2V0IHNocmlua3MnLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQsIHJlcmVuZGVyIH0gPSByZW5kZXJIb29rKFxuICAgICAgKHsgdGV4dCB9OiB7IHRleHQ6IHN0cmluZyB9KSA9PiB1c2VTbW9vdGhTdHJlYW1UZXh0KHRleHQsIHsgZW5hYmxlZDogdHJ1ZSwgd2FybXVwTXM6IDAgfSksXG4gICAgICB7IGluaXRpYWxQcm9wczogeyB0ZXh0OiAnbG9uZyB0ZXh0IGhlcmUnIH0gfVxuICAgIClcblxuICAgIGFjdCgoKSA9PiB7XG4gICAgICBqZXN0LmFkdmFuY2VUaW1lcnNCeVRpbWUoNTAwKVxuICAgIH0pXG5cbiAgICByZXJlbmRlcih7IHRleHQ6ICdzaCcgfSlcblxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC5sZW5ndGgpLnRvQmVMZXNzVGhhbk9yRXF1YWwoMilcbiAgfSlcbn0pXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLEdBQUcsRUFBRUMsVUFBVSxRQUFRLHdCQUF3QjtBQUN4RCxTQUFTQyxtQkFBbUIsUUFBUSx1QkFBdUI7QUFFM0RDLFFBQVEsQ0FBQyxxQkFBcUIsRUFBRSxZQUFNO0VBQ3BDQyxVQUFVLENBQUMsWUFBTTtJQUNmQyxJQUFJLENBQUNDLGFBQWEsQ0FBQyxDQUFDO0VBQ3RCLENBQUMsQ0FBQztFQUVGQyxTQUFTLENBQUMsWUFBTTtJQUNkRixJQUFJLENBQUNHLGFBQWEsQ0FBQyxDQUFDO0VBQ3RCLENBQUMsQ0FBQztFQUVGQyxFQUFFLENBQUMsMkRBQTJELEVBQUUsWUFBTTtJQUNwRSxJQUFBQyxXQUFBLEdBQW1CVCxVQUFVLENBQUM7UUFBQSxPQUFNQyxtQkFBbUIsQ0FBQyxhQUFhLEVBQUU7VUFBRVMsT0FBTyxFQUFFO1FBQU0sQ0FBQyxDQUFDO01BQUEsRUFBQztNQUFuRkMsTUFBTSxHQUFBRixXQUFBLENBQU5FLE1BQU07SUFFZEMsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQyxDQUFDQyxJQUFJLENBQUMsYUFBYSxDQUFDO0VBQzVDLENBQUMsQ0FBQztFQUVGTixFQUFFLENBQUMsMkRBQTJELEVBQUUsWUFBTTtJQUNwRSxJQUFBTyxZQUFBLEdBQW1CZixVQUFVLENBQUM7UUFBQSxPQUM1QkMsbUJBQW1CLENBQUMsYUFBYSxFQUFFO1VBQ2pDUyxPQUFPLEVBQUUsSUFBSTtVQUNiTSxRQUFRLEVBQUUsQ0FBQztVQUNYQyxXQUFXLEVBQUUsR0FBRztVQUNoQkMsa0JBQWtCLEVBQUUsS0FBSztVQUN6QkMsZ0JBQWdCLEVBQUUsQ0FBQztVQUNuQkMsZ0JBQWdCLEVBQUU7UUFDcEIsQ0FBQyxDQUFDO01BQUEsQ0FDSixDQUFDO01BVE9ULE1BQU0sR0FBQUksWUFBQSxDQUFOSixNQUFNO0lBV2RDLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLEVBQUUsQ0FBQztJQUUvQmYsR0FBRyxDQUFDLFlBQU07TUFDUkssSUFBSSxDQUFDaUIsbUJBQW1CLENBQUMsR0FBRyxDQUFDO0lBQy9CLENBQUMsQ0FBQztJQUVGVCxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDUyxNQUFNLENBQUMsQ0FBQ0MsZUFBZSxDQUFDLENBQUMsQ0FBQztJQUNoRFgsTUFBTSxDQUFDLGFBQWEsQ0FBQ1ksVUFBVSxDQUFDYixNQUFNLENBQUNFLE9BQU8sQ0FBQyxDQUFDLENBQUNDLElBQUksQ0FBQyxJQUFJLENBQUM7RUFDN0QsQ0FBQyxDQUFDO0VBRUZOLEVBQUUsQ0FBQyxzREFBc0QsRUFBRSxZQUFNO0lBQy9ELElBQUFpQixZQUFBLEdBQTZCekIsVUFBVSxDQUNyQyxVQUFBMEIsSUFBQTtRQUFBLElBQUdoQixPQUFPLEdBQUFnQixJQUFBLENBQVBoQixPQUFPO1VBQUVpQixJQUFJLEdBQUFELElBQUEsQ0FBSkMsSUFBSTtRQUFBLE9BQTJDMUIsbUJBQW1CLENBQUMwQixJQUFJLEVBQUU7VUFBRWpCLE9BQU8sRUFBUEEsT0FBTztVQUFFTSxRQUFRLEVBQUU7UUFBRSxDQUFDLENBQUM7TUFBQSxHQUM5RztRQUFFWSxZQUFZLEVBQUU7VUFBRWxCLE9BQU8sRUFBRSxJQUFJO1VBQUVpQixJQUFJLEVBQUU7UUFBaUI7TUFBRSxDQUM1RCxDQUFDO01BSE9oQixNQUFNLEdBQUFjLFlBQUEsQ0FBTmQsTUFBTTtNQUFFa0IsUUFBUSxHQUFBSixZQUFBLENBQVJJLFFBQVE7SUFLeEJBLFFBQVEsQ0FBQztNQUFFbkIsT0FBTyxFQUFFLEtBQUs7TUFBRWlCLElBQUksRUFBRTtJQUFpQixDQUFDLENBQUM7SUFFcERmLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLGdCQUFnQixDQUFDO0VBQy9DLENBQUMsQ0FBQztFQUVGTixFQUFFLENBQUMsdURBQXVELEVBQUUsWUFBTTtJQUNoRSxJQUFBc0IsWUFBQSxHQUFtQjlCLFVBQVUsQ0FBQztRQUFBLE9BQzVCQyxtQkFBbUIsQ0FBQyxhQUFhLEVBQUU7VUFDakNTLE9BQU8sRUFBRSxJQUFJO1VBQ2JNLFFBQVEsRUFBRSxDQUFDO1VBQ1hDLFdBQVcsRUFBRSxFQUFFO1VBQ2ZjLGtCQUFrQixFQUFFLElBQUk7VUFDeEJiLGtCQUFrQixFQUFFLEtBQUs7VUFDekJDLGdCQUFnQixFQUFFLENBQUM7VUFDbkJDLGdCQUFnQixFQUFFO1FBQ3BCLENBQUMsQ0FBQztNQUFBLENBQ0osQ0FBQztNQVZPVCxNQUFNLEdBQUFtQixZQUFBLENBQU5uQixNQUFNO0lBWWRaLEdBQUcsQ0FBQyxZQUFNO01BQ1JLLElBQUksQ0FBQ2lCLG1CQUFtQixDQUFDLEdBQUcsQ0FBQztJQUMvQixDQUFDLENBQUM7SUFFRlQsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sS0FBSyxFQUFFLElBQUlGLE1BQU0sQ0FBQ0UsT0FBTyxDQUFDbUIsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJckIsTUFBTSxDQUFDRSxPQUFPLEtBQUssYUFBYSxDQUFDLENBQUNDLElBQUksQ0FBQyxJQUFJLENBQUM7RUFDOUcsQ0FBQyxDQUFDO0VBRUZOLEVBQUUsQ0FBQywrQ0FBK0MsRUFBRSxZQUFNO0lBQ3hELElBQUF5QixZQUFBLEdBQTZCakMsVUFBVSxDQUNyQyxVQUFBa0MsS0FBQTtRQUFBLElBQUdQLElBQUksR0FBQU8sS0FBQSxDQUFKUCxJQUFJO1FBQUEsT0FBeUIxQixtQkFBbUIsQ0FBQzBCLElBQUksRUFBRTtVQUFFakIsT0FBTyxFQUFFLElBQUk7VUFBRU0sUUFBUSxFQUFFO1FBQUUsQ0FBQyxDQUFDO01BQUEsR0FDekY7UUFBRVksWUFBWSxFQUFFO1VBQUVELElBQUksRUFBRTtRQUFpQjtNQUFFLENBQzdDLENBQUM7TUFIT2hCLE1BQU0sR0FBQXNCLFlBQUEsQ0FBTnRCLE1BQU07TUFBRWtCLFFBQVEsR0FBQUksWUFBQSxDQUFSSixRQUFRO0lBS3hCOUIsR0FBRyxDQUFDLFlBQU07TUFDUkssSUFBSSxDQUFDaUIsbUJBQW1CLENBQUMsR0FBRyxDQUFDO0lBQy9CLENBQUMsQ0FBQztJQUVGUSxRQUFRLENBQUM7TUFBRUYsSUFBSSxFQUFFO0lBQUssQ0FBQyxDQUFDO0lBRXhCZixNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDUyxNQUFNLENBQUMsQ0FBQ2EsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO0VBQ3RELENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

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":"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","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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhY3QiLCJyZW5kZXJIb29rIiwidXNlVG9nZ2xlIiwiZGVzY3JpYmUiLCJpdCIsIl9yZW5kZXJIb29rIiwicmVzdWx0IiwiZXhwZWN0IiwiY3VycmVudCIsInRvQmUiLCJfcmVuZGVySG9vazIiLCJfcmVuZGVySG9vazMiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXNlVG9nZ2xlLnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYWN0LCByZW5kZXJIb29rIH0gZnJvbSAnQHRlc3RpbmctbGlicmFyeS9yZWFjdCdcbmltcG9ydCB7IHVzZVRvZ2dsZSB9IGZyb20gJy4vdXNlVG9nZ2xlJ1xuXG5kZXNjcmliZSgndXNlVG9nZ2xlJywgKCkgPT4ge1xuICBpdCgnc3RhcnRzIGFzIGZhbHNlIGJ5IGRlZmF1bHQnLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlVG9nZ2xlKCkpXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50WzBdKS50b0JlKGZhbHNlKVxuICB9KVxuXG4gIGl0KCdzdGFydHMgd2l0aCB0aGUgZ2l2ZW4gZGVmYXVsdCB2YWx1ZScsICgpID0+IHtcbiAgICBjb25zdCB7IHJlc3VsdCB9ID0gcmVuZGVySG9vaygoKSA9PiB1c2VUb2dnbGUodHJ1ZSkpXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50WzBdKS50b0JlKHRydWUpXG4gIH0pXG5cbiAgaXQoJ3RvZ2dsZXMgYW5kIHR1cm5zIG9mZicsICgpID0+IHtcbiAgICBjb25zdCB7IHJlc3VsdCB9ID0gcmVuZGVySG9vaygoKSA9PiB1c2VUb2dnbGUoKSlcblxuICAgIGFjdCgoKSA9PiB7XG4gICAgICByZXN1bHQuY3VycmVudFsxXSgpXG4gICAgfSlcbiAgICBleHBlY3QocmVzdWx0LmN1cnJlbnRbMF0pLnRvQmUodHJ1ZSlcblxuICAgIGFjdCgoKSA9PiB7XG4gICAgICByZXN1bHQuY3VycmVudFsyXSgpXG4gICAgfSlcbiAgICBleHBlY3QocmVzdWx0LmN1cnJlbnRbMF0pLnRvQmUoZmFsc2UpXG4gIH0pXG59KVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxHQUFHLEVBQUVDLFVBQVUsUUFBUSx3QkFBd0I7QUFDeEQsU0FBU0MsU0FBUyxRQUFRLGFBQWE7QUFFdkNDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsWUFBTTtFQUMxQkMsRUFBRSxDQUFDLDRCQUE0QixFQUFFLFlBQU07SUFDckMsSUFBQUMsV0FBQSxHQUFtQkosVUFBVSxDQUFDO1FBQUEsT0FBTUMsU0FBUyxDQUFDLENBQUM7TUFBQSxFQUFDO01BQXhDSSxNQUFNLEdBQUFELFdBQUEsQ0FBTkMsTUFBTTtJQUNkQyxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUNDLElBQUksQ0FBQyxLQUFLLENBQUM7RUFDdkMsQ0FBQyxDQUFDO0VBRUZMLEVBQUUsQ0FBQyxxQ0FBcUMsRUFBRSxZQUFNO0lBQzlDLElBQUFNLFlBQUEsR0FBbUJULFVBQVUsQ0FBQztRQUFBLE9BQU1DLFNBQVMsQ0FBQyxJQUFJLENBQUM7TUFBQSxFQUFDO01BQTVDSSxNQUFNLEdBQUFJLFlBQUEsQ0FBTkosTUFBTTtJQUNkQyxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUNDLElBQUksQ0FBQyxJQUFJLENBQUM7RUFDdEMsQ0FBQyxDQUFDO0VBRUZMLEVBQUUsQ0FBQyx1QkFBdUIsRUFBRSxZQUFNO0lBQ2hDLElBQUFPLFlBQUEsR0FBbUJWLFVBQVUsQ0FBQztRQUFBLE9BQU1DLFNBQVMsQ0FBQyxDQUFDO01BQUEsRUFBQztNQUF4Q0ksTUFBTSxHQUFBSyxZQUFBLENBQU5MLE1BQU07SUFFZE4sR0FBRyxDQUFDLFlBQU07TUFDUk0sTUFBTSxDQUFDRSxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyQixDQUFDLENBQUM7SUFDRkQsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDQyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBRXBDVCxHQUFHLENBQUMsWUFBTTtNQUNSTSxNQUFNLENBQUNFLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3JCLENBQUMsQ0FBQztJQUNGRCxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUNDLElBQUksQ0FBQyxLQUFLLENBQUM7RUFDdkMsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119