@projectcor/maia-components 2.38.4 → 2.39.1

package/lib/hooks/useDebounce.spec.js

@@ -0,0 +1,42 @@
+import { act, renderHook } from '@testing-library/react';
+import { useDebounce } from './useDebounce';
+describe('useDebounce', function () {
+  beforeEach(function () {
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+  });
+  it('returns the initial value immediately', function () {
+    var _renderHook = renderHook(function () {
+        return useDebounce('hola', 300);
+      }),
+      result = _renderHook.result;
+    expect(result.current).toBe('hola');
+  });
+  it('updates the value only after the delay', function () {
+    var _renderHook2 = renderHook(function (_ref) {
+        var value = _ref.value;
+        return useDebounce(value, 300);
+      }, {
+        initialProps: {
+          value: 'hola'
+        }
+      }),
+      result = _renderHook2.result,
+      rerender = _renderHook2.rerender;
+    rerender({
+      value: 'chau'
+    });
+    expect(result.current).toBe('hola');
+    act(function () {
+      jest.advanceTimersByTime(299);
+    });
+    expect(result.current).toBe('hola');
+    act(function () {
+      jest.advanceTimersByTime(1);
+    });
+    expect(result.current).toBe('chau');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useEvent.spec.js

@@ -0,0 +1,40 @@
+import { renderHook } from '@testing-library/react';
+import dispatchAmplitude from '@projectcor/cor-commons/lib/utils/dispatchAmplitude';
+import { EVENTS, useEvent } from './useEvent';
+jest.mock('@projectcor/cor-commons/lib/utils/dispatchAmplitude', function () {
+  return jest.fn();
+}, {
+  virtual: true
+});
+jest.mock('../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        company_id: 10,
+        id: 99
+      };
+    }
+  };
+});
+describe('useEvent', function () {
+  it('dispatches Amplitude with company and user ids', function () {
+    var _renderHook = renderHook(function () {
+        return useEvent();
+      }),
+      result = _renderHook.result;
+    result.current('AI_CHAT_SEND', {
+      extra: true
+    });
+    expect(dispatchAmplitude).toHaveBeenCalledWith('AI_CHAT_SEND', 10, {
+      companyId: 10,
+      userId: 99,
+      extra: true
+    });
+  });
+  it('exposes skill analytics event names', function () {
+    expect(EVENTS.aiSidebarMySkills).toBe('AI_SIDEBAR_MY_SKILLS');
+    expect(EVENTS.aiChatSkillSelect).toBe('AI_CHAT_SKILL_SELECT');
+    expect(EVENTS.aiChatSkillUse).toBe('AI_CHAT_SKILL_USE');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useMentionAllowedTypes.spec.js

@@ -0,0 +1,89 @@
+import { renderHook } from '@testing-library/react';
+import { useGlobalContext } from '../context/global-context';
+import { useMentionAllowedTypes } from './useMentionAllowedTypes';
+jest.mock('../context/global-context', function () {
+  return {
+    useGlobalContext: jest.fn()
+  };
+});
+var mockContext = useGlobalContext;
+describe('useMentionAllowedTypes', function () {
+  it('gives the orchestrator all COR types', function () {
+    mockContext.mockReturnValue({
+      agent: {
+        type: 'orchestrator'
+      }
+    });
+    var _renderHook = renderHook(function () {
+        return useMentionAllowedTypes();
+      }),
+      result = _renderHook.result;
+    expect(result.current.allowedTypes).toEqual(['user', 'task', 'project', 'client']);
+    expect(result.current.defaultType).toBe('user');
+  });
+  it('derives custom agent types from COR connectors and MCP', function () {
+    mockContext.mockReturnValue({
+      agent: {
+        type: 'custom',
+        connectors: [{
+          group: 'COR',
+          slugs: ['tareas']
+        }, {
+          group: 'MCP',
+          slugs: ['jira']
+        }]
+      }
+    });
+    var _renderHook2 = renderHook(function () {
+        return useMentionAllowedTypes();
+      }),
+      result = _renderHook2.result;
+    expect(result.current.allowedTypes).toEqual(['user', 'task', 'mcp']);
+  });
+  it('restricts project clones to user and task', function () {
+    mockContext.mockReturnValue({
+      agent: {
+        type: 'clone',
+        entity: 'project'
+      }
+    });
+    var _renderHook3 = renderHook(function () {
+        return useMentionAllowedTypes();
+      }),
+      result = _renderHook3.result;
+    expect(result.current.allowedTypes).toEqual(['user', 'task']);
+  });
+  it('does not expose skills in @-mentions for global clones', function () {
+    mockContext.mockReturnValue({
+      agent: {
+        type: 'clone',
+        entity: 'global'
+      }
+    });
+    var _renderHook4 = renderHook(function () {
+        return useMentionAllowedTypes();
+      }),
+      result = _renderHook4.result;
+    expect(result.current).toEqual({
+      allowedTypes: [],
+      defaultType: 'user'
+    });
+  });
+  it('lets the override win for clone agents', function () {
+    mockContext.mockReturnValue({
+      agent: {
+        type: 'clone',
+        entity: 'project'
+      }
+    });
+    var _renderHook5 = renderHook(function () {
+        return useMentionAllowedTypes(['client']);
+      }),
+      result = _renderHook5.result;
+    expect(result.current).toEqual({
+      allowedTypes: ['client'],
+      defaultType: 'client'
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJyZW5kZXJIb29rIiwidXNlR2xvYmFsQ29udGV4dCIsInVzZU1lbnRpb25BbGxvd2VkVHlwZXMiLCJqZXN0IiwibW9jayIsImZuIiwibW9ja0NvbnRleHQiLCJkZXNjcmliZSIsIml0IiwibW9ja1JldHVyblZhbHVlIiwiYWdlbnQiLCJ0eXBlIiwiX3JlbmRlckhvb2siLCJyZXN1bHQiLCJleHBlY3QiLCJjdXJyZW50IiwiYWxsb3dlZFR5cGVzIiwidG9FcXVhbCIsImRlZmF1bHRUeXBlIiwidG9CZSIsImNvbm5lY3RvcnMiLCJncm91cCIsInNsdWdzIiwiX3JlbmRlckhvb2syIiwiZW50aXR5IiwiX3JlbmRlckhvb2szIiwiX3JlbmRlckhvb2s0IiwiX3JlbmRlckhvb2s1Il0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3VzZU1lbnRpb25BbGxvd2VkVHlwZXMuc3BlYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyByZW5kZXJIb29rIH0gZnJvbSAnQHRlc3RpbmctbGlicmFyeS9yZWFjdCdcbmltcG9ydCB7IHVzZUdsb2JhbENvbnRleHQgfSBmcm9tICcuLi9jb250ZXh0L2dsb2JhbC1jb250ZXh0J1xuaW1wb3J0IHsgdXNlTWVudGlvbkFsbG93ZWRUeXBlcyB9IGZyb20gJy4vdXNlTWVudGlvbkFsbG93ZWRUeXBlcydcblxuamVzdC5tb2NrKCcuLi9jb250ZXh0L2dsb2JhbC1jb250ZXh0JywgKCkgPT4gKHtcbiAgdXNlR2xvYmFsQ29udGV4dDogamVzdC5mbigpLFxufSkpXG5cbmNvbnN0IG1vY2tDb250ZXh0ID0gdXNlR2xvYmFsQ29udGV4dCBhcyBqZXN0Lk1vY2tlZEZ1bmN0aW9uPHR5cGVvZiB1c2VHbG9iYWxDb250ZXh0PlxuXG5kZXNjcmliZSgndXNlTWVudGlvbkFsbG93ZWRUeXBlcycsICgpID0+IHtcbiAgaXQoJ2dpdmVzIHRoZSBvcmNoZXN0cmF0b3IgYWxsIENPUiB0eXBlcycsICgpID0+IHtcbiAgICBtb2NrQ29udGV4dC5tb2NrUmV0dXJuVmFsdWUoeyBhZ2VudDogeyB0eXBlOiAnb3JjaGVzdHJhdG9yJyB9IH0gYXMgbmV2ZXIpXG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlTWVudGlvbkFsbG93ZWRUeXBlcygpKVxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC5hbGxvd2VkVHlwZXMpLnRvRXF1YWwoWyd1c2VyJywgJ3Rhc2snLCAncHJvamVjdCcsICdjbGllbnQnXSlcbiAgICBleHBlY3QocmVzdWx0LmN1cnJlbnQuZGVmYXVsdFR5cGUpLnRvQmUoJ3VzZXInKVxuICB9KVxuXG4gIGl0KCdkZXJpdmVzIGN1c3RvbSBhZ2VudCB0eXBlcyBmcm9tIENPUiBjb25uZWN0b3JzIGFuZCBNQ1AnLCAoKSA9PiB7XG4gICAgbW9ja0NvbnRleHQubW9ja1JldHVyblZhbHVlKHtcbiAgICAgIGFnZW50OiB7XG4gICAgICAgIHR5cGU6ICdjdXN0b20nLFxuICAgICAgICBjb25uZWN0b3JzOiBbXG4gICAgICAgICAgeyBncm91cDogJ0NPUicsIHNsdWdzOiBbJ3RhcmVhcyddIH0sXG4gICAgICAgICAgeyBncm91cDogJ01DUCcsIHNsdWdzOiBbJ2ppcmEnXSB9LFxuICAgICAgICBdLFxuICAgICAgfSxcbiAgICB9IGFzIG5ldmVyKVxuXG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlTWVudGlvbkFsbG93ZWRUeXBlcygpKVxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC5hbGxvd2VkVHlwZXMpLnRvRXF1YWwoWyd1c2VyJywgJ3Rhc2snLCAnbWNwJ10pXG4gIH0pXG5cbiAgaXQoJ3Jlc3RyaWN0cyBwcm9qZWN0IGNsb25lcyB0byB1c2VyIGFuZCB0YXNrJywgKCkgPT4ge1xuICAgIG1vY2tDb250ZXh0Lm1vY2tSZXR1cm5WYWx1ZSh7IGFnZW50OiB7IHR5cGU6ICdjbG9uZScsIGVudGl0eTogJ3Byb2plY3QnIH0gfSBhcyBuZXZlcilcbiAgICBjb25zdCB7IHJlc3VsdCB9ID0gcmVuZGVySG9vaygoKSA9PiB1c2VNZW50aW9uQWxsb3dlZFR5cGVzKCkpXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50LmFsbG93ZWRUeXBlcykudG9FcXVhbChbJ3VzZXInLCAndGFzayddKVxuICB9KVxuXG4gIGl0KCdkb2VzIG5vdCBleHBvc2Ugc2tpbGxzIGluIEAtbWVudGlvbnMgZm9yIGdsb2JhbCBjbG9uZXMnLCAoKSA9PiB7XG4gICAgbW9ja0NvbnRleHQubW9ja1JldHVyblZhbHVlKHsgYWdlbnQ6IHsgdHlwZTogJ2Nsb25lJywgZW50aXR5OiAnZ2xvYmFsJyB9IH0gYXMgbmV2ZXIpXG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlTWVudGlvbkFsbG93ZWRUeXBlcygpKVxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudCkudG9FcXVhbCh7IGFsbG93ZWRUeXBlczogW10sIGRlZmF1bHRUeXBlOiAndXNlcicgfSlcbiAgfSlcblxuICBpdCgnbGV0cyB0aGUgb3ZlcnJpZGUgd2luIGZvciBjbG9uZSBhZ2VudHMnLCAoKSA9PiB7XG4gICAgbW9ja0NvbnRleHQubW9ja1JldHVyblZhbHVlKHsgYWdlbnQ6IHsgdHlwZTogJ2Nsb25lJywgZW50aXR5OiAncHJvamVjdCcgfSB9IGFzIG5ldmVyKVxuICAgIGNvbnN0IHsgcmVzdWx0IH0gPSByZW5kZXJIb29rKCgpID0+IHVzZU1lbnRpb25BbGxvd2VkVHlwZXMoWydjbGllbnQnXSkpXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50KS50b0VxdWFsKHsgYWxsb3dlZFR5cGVzOiBbJ2NsaWVudCddLCBkZWZhdWx0VHlwZTogJ2NsaWVudCcgfSlcbiAgfSlcbn0pXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFVBQVUsUUFBUSx3QkFBd0I7QUFDbkQsU0FBU0MsZ0JBQWdCLFFBQVEsMkJBQTJCO0FBQzVELFNBQVNDLHNCQUFzQixRQUFRLDBCQUEwQjtBQUVqRUMsSUFBSSxDQUFDQyxJQUFJLENBQUMsMkJBQTJCLEVBQUU7RUFBQSxPQUFPO0lBQzVDSCxnQkFBZ0IsRUFBRUUsSUFBSSxDQUFDRSxFQUFFLENBQUM7RUFDNUIsQ0FBQztBQUFBLENBQUMsQ0FBQztBQUVILElBQU1DLFdBQVcsR0FBR0wsZ0JBQWdFO0FBRXBGTSxRQUFRLENBQUMsd0JBQXdCLEVBQUUsWUFBTTtFQUN2Q0MsRUFBRSxDQUFDLHNDQUFzQyxFQUFFLFlBQU07SUFDL0NGLFdBQVcsQ0FBQ0csZUFBZSxDQUFDO01BQUVDLEtBQUssRUFBRTtRQUFFQyxJQUFJLEVBQUU7TUFBZTtJQUFFLENBQVUsQ0FBQztJQUN6RSxJQUFBQyxXQUFBLEdBQW1CWixVQUFVLENBQUM7UUFBQSxPQUFNRSxzQkFBc0IsQ0FBQyxDQUFDO01BQUEsRUFBQztNQUFyRFcsTUFBTSxHQUFBRCxXQUFBLENBQU5DLE1BQU07SUFDZEMsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQ0MsWUFBWSxDQUFDLENBQUNDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ2xGSCxNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDRyxXQUFXLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLE1BQU0sQ0FBQztFQUNqRCxDQUFDLENBQUM7RUFFRlgsRUFBRSxDQUFDLHdEQUF3RCxFQUFFLFlBQU07SUFDakVGLFdBQVcsQ0FBQ0csZUFBZSxDQUFDO01BQzFCQyxLQUFLLEVBQUU7UUFDTEMsSUFBSSxFQUFFLFFBQVE7UUFDZFMsVUFBVSxFQUFFLENBQ1Y7VUFBRUMsS0FBSyxFQUFFLEtBQUs7VUFBRUMsS0FBSyxFQUFFLENBQUMsUUFBUTtRQUFFLENBQUMsRUFDbkM7VUFBRUQsS0FBSyxFQUFFLEtBQUs7VUFBRUMsS0FBSyxFQUFFLENBQUMsTUFBTTtRQUFFLENBQUM7TUFFckM7SUFDRixDQUFVLENBQUM7SUFFWCxJQUFBQyxZQUFBLEdBQW1CdkIsVUFBVSxDQUFDO1FBQUEsT0FBTUUsc0JBQXNCLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBckRXLE1BQU0sR0FBQVUsWUFBQSxDQUFOVixNQUFNO0lBQ2RDLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUNDLFlBQVksQ0FBQyxDQUFDQyxPQUFPLENBQUMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0VBQ3RFLENBQUMsQ0FBQztFQUVGVCxFQUFFLENBQUMsMkNBQTJDLEVBQUUsWUFBTTtJQUNwREYsV0FBVyxDQUFDRyxlQUFlLENBQUM7TUFBRUMsS0FBSyxFQUFFO1FBQUVDLElBQUksRUFBRSxPQUFPO1FBQUVhLE1BQU0sRUFBRTtNQUFVO0lBQUUsQ0FBVSxDQUFDO0lBQ3JGLElBQUFDLFlBQUEsR0FBbUJ6QixVQUFVLENBQUM7UUFBQSxPQUFNRSxzQkFBc0IsQ0FBQyxDQUFDO01BQUEsRUFBQztNQUFyRFcsTUFBTSxHQUFBWSxZQUFBLENBQU5aLE1BQU07SUFDZEMsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQ0MsWUFBWSxDQUFDLENBQUNDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztFQUMvRCxDQUFDLENBQUM7RUFFRlQsRUFBRSxDQUFDLHdEQUF3RCxFQUFFLFlBQU07SUFDakVGLFdBQVcsQ0FBQ0csZUFBZSxDQUFDO01BQUVDLEtBQUssRUFBRTtRQUFFQyxJQUFJLEVBQUUsT0FBTztRQUFFYSxNQUFNLEVBQUU7TUFBUztJQUFFLENBQVUsQ0FBQztJQUNwRixJQUFBRSxZQUFBLEdBQW1CMUIsVUFBVSxDQUFDO1FBQUEsT0FBTUUsc0JBQXNCLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBckRXLE1BQU0sR0FBQWEsWUFBQSxDQUFOYixNQUFNO0lBQ2RDLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUMsQ0FBQ0UsT0FBTyxDQUFDO01BQUVELFlBQVksRUFBRSxFQUFFO01BQUVFLFdBQVcsRUFBRTtJQUFPLENBQUMsQ0FBQztFQUMzRSxDQUFDLENBQUM7RUFFRlYsRUFBRSxDQUFDLHdDQUF3QyxFQUFFLFlBQU07SUFDakRGLFdBQVcsQ0FBQ0csZUFBZSxDQUFDO01BQUVDLEtBQUssRUFBRTtRQUFFQyxJQUFJLEVBQUUsT0FBTztRQUFFYSxNQUFNLEVBQUU7TUFBVTtJQUFFLENBQVUsQ0FBQztJQUNyRixJQUFBRyxZQUFBLEdBQW1CM0IsVUFBVSxDQUFDO1FBQUEsT0FBTUUsc0JBQXNCLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBL0RXLE1BQU0sR0FBQWMsWUFBQSxDQUFOZCxNQUFNO0lBQ2RDLE1BQU0sQ0FBQ0QsTUFBTSxDQUFDRSxPQUFPLENBQUMsQ0FBQ0UsT0FBTyxDQUFDO01BQUVELFlBQVksRUFBRSxDQUFDLFFBQVEsQ0FBQztNQUFFRSxXQUFXLEVBQUU7SUFBUyxDQUFDLENBQUM7RUFDckYsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwiaWdub3JlTGlzdCI6W119

package/lib/hooks/useModal/useModal.spec.js

@@ -0,0 +1,73 @@
+import { act, renderHook } from '@testing-library/react';
+import { createRef } from 'react';
+import { useModal } from './useModal';
+describe('useModal', function () {
+  it('starts closed unless initialOpen is true', function () {
+    var _renderHook = renderHook(function () {
+        return useModal({});
+      }),
+      closed = _renderHook.result;
+    expect(closed.current.isOpen).toBe(false);
+    var _renderHook2 = renderHook(function () {
+        return useModal({
+          initialOpen: true
+        });
+      }),
+      opened = _renderHook2.result;
+    expect(opened.current.isOpen).toBe(true);
+  });
+  it('toggles open state', function () {
+    var _renderHook3 = renderHook(function () {
+        return useModal({});
+      }),
+      result = _renderHook3.result;
+    act(function () {
+      result.current.toggleModal();
+    });
+    expect(result.current.isOpen).toBe(true);
+  });
+  it('closes on outside click and calls onClose', function () {
+    var onClose = jest.fn();
+    var _renderHook4 = renderHook(function () {
+        return useModal({
+          initialOpen: true,
+          onClose: onClose
+        });
+      }),
+      result = _renderHook4.result;
+    var outside = document.createElement('button');
+    document.body.appendChild(outside);
+    act(function () {
+      outside.dispatchEvent(new MouseEvent('click', {
+        bubbles: true
+      }));
+    });
+    outside.remove();
+    expect(result.current.isOpen).toBe(false);
+    expect(onClose).toHaveBeenCalled();
+  });
+  it('does not close when clicking inside the ref', function () {
+    var ref = /*#__PURE__*/createRef();
+    var node = document.createElement('div');
+    document.body.appendChild(node);
+    Object.defineProperty(ref, 'current', {
+      value: node,
+      writable: true
+    });
+    var _renderHook5 = renderHook(function () {
+        return useModal({
+          ref: ref,
+          initialOpen: true
+        });
+      }),
+      result = _renderHook5.result;
+    act(function () {
+      node.dispatchEvent(new MouseEvent('click', {
+        bubbles: true
+      }));
+    });
+    expect(result.current.isOpen).toBe(true);
+    node.remove();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJhY3QiLCJyZW5kZXJIb29rIiwiY3JlYXRlUmVmIiwidXNlTW9kYWwiLCJkZXNjcmliZSIsIml0IiwiX3JlbmRlckhvb2siLCJjbG9zZWQiLCJyZXN1bHQiLCJleHBlY3QiLCJjdXJyZW50IiwiaXNPcGVuIiwidG9CZSIsIl9yZW5kZXJIb29rMiIsImluaXRpYWxPcGVuIiwib3BlbmVkIiwiX3JlbmRlckhvb2szIiwidG9nZ2xlTW9kYWwiLCJvbkNsb3NlIiwiamVzdCIsImZuIiwiX3JlbmRlckhvb2s0Iiwib3V0c2lkZSIsImRvY3VtZW50IiwiY3JlYXRlRWxlbWVudCIsImJvZHkiLCJhcHBlbmRDaGlsZCIsImRpc3BhdGNoRXZlbnQiLCJNb3VzZUV2ZW50IiwiYnViYmxlcyIsInJlbW92ZSIsInRvSGF2ZUJlZW5DYWxsZWQiLCJyZWYiLCJub2RlIiwiT2JqZWN0IiwiZGVmaW5lUHJvcGVydHkiLCJ2YWx1ZSIsIndyaXRhYmxlIiwiX3JlbmRlckhvb2s1Il0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL3VzZU1vZGFsL3VzZU1vZGFsLnNwZWMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYWN0LCByZW5kZXJIb29rIH0gZnJvbSAnQHRlc3RpbmctbGlicmFyeS9yZWFjdCdcbmltcG9ydCB7IGNyZWF0ZVJlZiB9IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgdXNlTW9kYWwgfSBmcm9tICcuL3VzZU1vZGFsJ1xuXG5kZXNjcmliZSgndXNlTW9kYWwnLCAoKSA9PiB7XG4gIGl0KCdzdGFydHMgY2xvc2VkIHVubGVzcyBpbml0aWFsT3BlbiBpcyB0cnVlJywgKCkgPT4ge1xuICAgIGNvbnN0IHsgcmVzdWx0OiBjbG9zZWQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlTW9kYWwoe30pKVxuICAgIGV4cGVjdChjbG9zZWQuY3VycmVudC5pc09wZW4pLnRvQmUoZmFsc2UpXG5cbiAgICBjb25zdCB7IHJlc3VsdDogb3BlbmVkIH0gPSByZW5kZXJIb29rKCgpID0+IHVzZU1vZGFsKHsgaW5pdGlhbE9wZW46IHRydWUgfSkpXG4gICAgZXhwZWN0KG9wZW5lZC5jdXJyZW50LmlzT3BlbikudG9CZSh0cnVlKVxuICB9KVxuXG4gIGl0KCd0b2dnbGVzIG9wZW4gc3RhdGUnLCAoKSA9PiB7XG4gICAgY29uc3QgeyByZXN1bHQgfSA9IHJlbmRlckhvb2soKCkgPT4gdXNlTW9kYWwoe30pKVxuXG4gICAgYWN0KCgpID0+IHtcbiAgICAgIHJlc3VsdC5jdXJyZW50LnRvZ2dsZU1vZGFsKClcbiAgICB9KVxuICAgIGV4cGVjdChyZXN1bHQuY3VycmVudC5pc09wZW4pLnRvQmUodHJ1ZSlcbiAgfSlcblxuICBpdCgnY2xvc2VzIG9uIG91dHNpZGUgY2xpY2sgYW5kIGNhbGxzIG9uQ2xvc2UnLCAoKSA9PiB7XG4gICAgY29uc3Qgb25DbG9zZSA9IGplc3QuZm4oKVxuICAgIGNvbnN0IHsgcmVzdWx0IH0gPSByZW5kZXJIb29rKCgpID0+IHVzZU1vZGFsKHsgaW5pdGlhbE9wZW46IHRydWUsIG9uQ2xvc2UgfSkpXG5cbiAgICBjb25zdCBvdXRzaWRlID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnYnV0dG9uJylcbiAgICBkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKG91dHNpZGUpXG5cbiAgICBhY3QoKCkgPT4ge1xuICAgICAgb3V0c2lkZS5kaXNwYXRjaEV2ZW50KG5ldyBNb3VzZUV2ZW50KCdjbGljaycsIHsgYnViYmxlczogdHJ1ZSB9KSlcbiAgICB9KVxuXG4gICAgb3V0c2lkZS5yZW1vdmUoKVxuXG4gICAgZXhwZWN0KHJlc3VsdC5jdXJyZW50LmlzT3BlbikudG9CZShmYWxzZSlcbiAgICBleHBlY3Qob25DbG9zZSkudG9IYXZlQmVlbkNhbGxlZCgpXG4gIH0pXG5cbiAgaXQoJ2RvZXMgbm90IGNsb3NlIHdoZW4gY2xpY2tpbmcgaW5zaWRlIHRoZSByZWYnLCAoKSA9PiB7XG4gICAgY29uc3QgcmVmID0gY3JlYXRlUmVmPEhUTUxEaXZFbGVtZW50PigpXG4gICAgY29uc3Qgbm9kZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpXG4gICAgZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChub2RlKVxuICAgIE9iamVjdC5kZWZpbmVQcm9wZXJ0eShyZWYsICdjdXJyZW50JywgeyB2YWx1ZTogbm9kZSwgd3JpdGFibGU6IHRydWUgfSlcblxuICAgIGNvbnN0IHsgcmVzdWx0IH0gPSByZW5kZXJIb29rKCgpID0+IHVzZU1vZGFsKHsgcmVmLCBpbml0aWFsT3BlbjogdHJ1ZSB9KSlcblxuICAgIGFjdCgoKSA9PiB7XG4gICAgICBub2RlLmRpc3BhdGNoRXZlbnQobmV3IE1vdXNlRXZlbnQoJ2NsaWNrJywgeyBidWJibGVzOiB0cnVlIH0pKVxuICAgIH0pXG5cbiAgICBleHBlY3QocmVzdWx0LmN1cnJlbnQuaXNPcGVuKS50b0JlKHRydWUpXG4gICAgbm9kZS5yZW1vdmUoKVxuICB9KVxufSlcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsR0FBRyxFQUFFQyxVQUFVLFFBQVEsd0JBQXdCO0FBQ3hELFNBQVNDLFNBQVMsUUFBUSxPQUFPO0FBQ2pDLFNBQVNDLFFBQVEsUUFBUSxZQUFZO0FBRXJDQyxRQUFRLENBQUMsVUFBVSxFQUFFLFlBQU07RUFDekJDLEVBQUUsQ0FBQywwQ0FBMEMsRUFBRSxZQUFNO0lBQ25ELElBQUFDLFdBQUEsR0FBMkJMLFVBQVUsQ0FBQztRQUFBLE9BQU1FLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBekNJLE1BQU0sR0FBQUQsV0FBQSxDQUFkRSxNQUFNO0lBQ2RDLE1BQU0sQ0FBQ0YsTUFBTSxDQUFDRyxPQUFPLENBQUNDLE1BQU0sQ0FBQyxDQUFDQyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBRXpDLElBQUFDLFlBQUEsR0FBMkJaLFVBQVUsQ0FBQztRQUFBLE9BQU1FLFFBQVEsQ0FBQztVQUFFVyxXQUFXLEVBQUU7UUFBSyxDQUFDLENBQUM7TUFBQSxFQUFDO01BQTVEQyxNQUFNLEdBQUFGLFlBQUEsQ0FBZEwsTUFBTTtJQUNkQyxNQUFNLENBQUNNLE1BQU0sQ0FBQ0wsT0FBTyxDQUFDQyxNQUFNLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLElBQUksQ0FBQztFQUMxQyxDQUFDLENBQUM7RUFFRlAsRUFBRSxDQUFDLG9CQUFvQixFQUFFLFlBQU07SUFDN0IsSUFBQVcsWUFBQSxHQUFtQmYsVUFBVSxDQUFDO1FBQUEsT0FBTUUsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO01BQUEsRUFBQztNQUF6Q0ssTUFBTSxHQUFBUSxZQUFBLENBQU5SLE1BQU07SUFFZFIsR0FBRyxDQUFDLFlBQU07TUFDUlEsTUFBTSxDQUFDRSxPQUFPLENBQUNPLFdBQVcsQ0FBQyxDQUFDO0lBQzlCLENBQUMsQ0FBQztJQUNGUixNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDQyxNQUFNLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLElBQUksQ0FBQztFQUMxQyxDQUFDLENBQUM7RUFFRlAsRUFBRSxDQUFDLDJDQUEyQyxFQUFFLFlBQU07SUFDcEQsSUFBTWEsT0FBTyxHQUFHQyxJQUFJLENBQUNDLEVBQUUsQ0FBQyxDQUFDO0lBQ3pCLElBQUFDLFlBQUEsR0FBbUJwQixVQUFVLENBQUM7UUFBQSxPQUFNRSxRQUFRLENBQUM7VUFBRVcsV0FBVyxFQUFFLElBQUk7VUFBRUksT0FBTyxFQUFQQTtRQUFRLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBckVWLE1BQU0sR0FBQWEsWUFBQSxDQUFOYixNQUFNO0lBRWQsSUFBTWMsT0FBTyxHQUFHQyxRQUFRLENBQUNDLGFBQWEsQ0FBQyxRQUFRLENBQUM7SUFDaERELFFBQVEsQ0FBQ0UsSUFBSSxDQUFDQyxXQUFXLENBQUNKLE9BQU8sQ0FBQztJQUVsQ3RCLEdBQUcsQ0FBQyxZQUFNO01BQ1JzQixPQUFPLENBQUNLLGFBQWEsQ0FBQyxJQUFJQyxVQUFVLENBQUMsT0FBTyxFQUFFO1FBQUVDLE9BQU8sRUFBRTtNQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ25FLENBQUMsQ0FBQztJQUVGUCxPQUFPLENBQUNRLE1BQU0sQ0FBQyxDQUFDO0lBRWhCckIsTUFBTSxDQUFDRCxNQUFNLENBQUNFLE9BQU8sQ0FBQ0MsTUFBTSxDQUFDLENBQUNDLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDekNILE1BQU0sQ0FBQ1MsT0FBTyxDQUFDLENBQUNhLGdCQUFnQixDQUFDLENBQUM7RUFDcEMsQ0FBQyxDQUFDO0VBRUYxQixFQUFFLENBQUMsNkNBQTZDLEVBQUUsWUFBTTtJQUN0RCxJQUFNMkIsR0FBRyxnQkFBRzlCLFNBQVMsQ0FBaUIsQ0FBQztJQUN2QyxJQUFNK0IsSUFBSSxHQUFHVixRQUFRLENBQUNDLGFBQWEsQ0FBQyxLQUFLLENBQUM7SUFDMUNELFFBQVEsQ0FBQ0UsSUFBSSxDQUFDQyxXQUFXLENBQUNPLElBQUksQ0FBQztJQUMvQkMsTUFBTSxDQUFDQyxjQUFjLENBQUNILEdBQUcsRUFBRSxTQUFTLEVBQUU7TUFBRUksS0FBSyxFQUFFSCxJQUFJO01BQUVJLFFBQVEsRUFBRTtJQUFLLENBQUMsQ0FBQztJQUV0RSxJQUFBQyxZQUFBLEdBQW1CckMsVUFBVSxDQUFDO1FBQUEsT0FBTUUsUUFBUSxDQUFDO1VBQUU2QixHQUFHLEVBQUhBLEdBQUc7VUFBRWxCLFdBQVcsRUFBRTtRQUFLLENBQUMsQ0FBQztNQUFBLEVBQUM7TUFBakVOLE1BQU0sR0FBQThCLFlBQUEsQ0FBTjlCLE1BQU07SUFFZFIsR0FBRyxDQUFDLFlBQU07TUFDUmlDLElBQUksQ0FBQ04sYUFBYSxDQUFDLElBQUlDLFVBQVUsQ0FBQyxPQUFPLEVBQUU7UUFBRUMsT0FBTyxFQUFFO01BQUssQ0FBQyxDQUFDLENBQUM7SUFDaEUsQ0FBQyxDQUFDO0lBRUZwQixNQUFNLENBQUNELE1BQU0sQ0FBQ0UsT0FBTyxDQUFDQyxNQUFNLENBQUMsQ0FBQ0MsSUFBSSxDQUFDLElBQUksQ0FBQztJQUN4Q3FCLElBQUksQ0FBQ0gsTUFBTSxDQUFDLENBQUM7RUFDZixDQUFDLENBQUM7QUFDSixDQUFDLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/hooks/useResize.spec.js

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

package/lib/hooks/useSkillsCatalog.spec.js

@@ -0,0 +1,88 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { lastFetch, mockJsonError, mockJsonOk } from '../test/mockFetch';
+import { useSkillsCatalog } from './useSkillsCatalog';
+var skill = function skill(id, name) {
+  return {
+    id: id,
+    name: name,
+    description: '',
+    content: 'body',
+    access_type: 'only_me'
+  };
+};
+describe('useSkillsCatalog', function () {
+  it('loads skills sorted by name', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          mockJsonOk({
+            data: [skill('2', 'Zebra'), skill('1', 'Alpha')]
+          });
+          _renderHook = renderHook(function () {
+            return useSkillsCatalog();
+          }), 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.fetchSkills();
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(lastFetch()).toMatchObject({
+            url: 'https://maia.test/skills?limit=100&offset=0&scope=all',
+            method: 'GET'
+          });
+          expect(result.current.skills.map(function (item) {
+            return item.name;
+          })).toEqual(['Alpha', 'Zebra']);
+          expect(result.current.error).toBe(false);
+          expect(result.current.loading).toBe(false);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('clears the list and flags error when the request fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          mockJsonError(500);
+          _renderHook2 = renderHook(function () {
+            return useSkillsCatalog();
+          }), 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.fetchSkills();
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(result.current.skills).toEqual([]);
+          expect(result.current.error).toBe(true);
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+});
+//# 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/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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