@jobber/hooks 2.17.2 → 2.17.3

package/dist/useDebounce/useDebounce.test.js

@@ -1,3 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,10 +31,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React, { useEffect, useState } from "react";
-import { act, render, renderHook, screen } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { useDebounce } from "./useDebounce";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const react_2 = require("@testing-library/react");
+const user_event_1 = __importDefault(require("@testing-library/user-event"));
+const useDebounce_1 = require("./useDebounce");
 const DEBOUNCE_WAIT = 300;
 describe("useDebounce", () => {
     beforeEach(() => {
@@ -21,10 +49,10 @@ describe("useDebounce", () => {
     });
     it("should debounce the function call", () => __awaiter(void 0, void 0, void 0, function* () {
         const mockFn = jest.fn();
-        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
+        const { result } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
         result.current("test");
         expect(mockFn).not.toHaveBeenCalled();
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).toHaveBeenCalledWith("test");
@@ -32,23 +60,23 @@ describe("useDebounce", () => {
     }));
     it("should cancel pending debounced calls on unmount", () => {
         const mockFn = jest.fn();
-        const { result, unmount } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
+        const { result, unmount } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
         result.current("test");
         unmount();
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).not.toHaveBeenCalled();
     });
     it("should handle multiple calls within the debounce period", () => {
         const mockFn = jest.fn();
-        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
+        const { result } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
         result.current("first");
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT / 2);
         });
         result.current("second");
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).toHaveBeenCalledTimes(1);
@@ -58,7 +86,7 @@ describe("useDebounce", () => {
         const mockFn = jest.fn();
         const debounceEgdesOption = ["trailing"];
         // Use a function that returns a new options object each time
-        const { result, rerender } = renderHook(({ options }) => useDebounce(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
+        const { result, rerender } = (0, react_2.renderHook)(({ options }) => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
         const debounceRef = result.current;
         rerender({ options: { edges: debounceEgdesOption } });
         expect(debounceRef).toBe(result.current);
@@ -70,16 +98,16 @@ describe("useDebounce", () => {
         // Start with trailing edge
         const debounceEgdesOption = ["trailing"];
         // Use a function that returns a new options object each time
-        const { result, rerender } = renderHook(({ options }) => useDebounce(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
+        const { result, rerender } = (0, react_2.renderHook)(({ options }) => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
         result.current("first");
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(TIME_INCREMENT_LESSER_THAN_DEBOUNCE_WAIT);
         });
         expect(mockFn).not.toHaveBeenCalled();
         // This means it calls immediately at the leading edge of the timeout.
         rerender({ options: { edges: ["leading"] } });
         result.current("second");
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(TIME_INCREMENT_LESSER_THAN_DEBOUNCE_WAIT);
         });
         // The config change should be ignored, options are hardcoded
@@ -87,52 +115,52 @@ describe("useDebounce", () => {
     });
     it("should work with React components", () => __awaiter(void 0, void 0, void 0, function* () {
         function DebouncedComponent() {
-            const [value, setValue] = useState("");
-            const [debouncedValue, setDebouncedValue] = useState("");
-            const debouncedSetValue = useDebounce((newValue) => {
+            const [value, setValue] = (0, react_1.useState)("");
+            const [debouncedValue, setDebouncedValue] = (0, react_1.useState)("");
+            const debouncedSetValue = (0, useDebounce_1.useDebounce)((newValue) => {
                 setDebouncedValue(newValue);
             }, DEBOUNCE_WAIT);
-            useEffect(() => {
+            (0, react_1.useEffect)(() => {
                 debouncedSetValue(value);
             }, [value, debouncedSetValue]);
-            return (React.createElement("div", null,
-                React.createElement("input", { "data-testid": "input", value: value, onChange: e => setValue(e.target.value) }),
-                React.createElement("div", { "data-testid": "debounced-value" }, debouncedValue)));
+            return (react_1.default.createElement("div", null,
+                react_1.default.createElement("input", { "data-testid": "input", value: value, onChange: e => setValue(e.target.value) }),
+                react_1.default.createElement("div", { "data-testid": "debounced-value" }, debouncedValue)));
         }
-        render(React.createElement(DebouncedComponent, null));
-        const input = screen.getByTestId("input");
-        const debouncedValue = screen.getByTestId("debounced-value");
-        const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+        (0, react_2.render)(react_1.default.createElement(DebouncedComponent, null));
+        const input = react_2.screen.getByTestId("input");
+        const debouncedValue = react_2.screen.getByTestId("debounced-value");
+        const user = user_event_1.default.setup({ advanceTimers: jest.advanceTimersByTime });
         yield user.type(input, "test");
         expect(debouncedValue.textContent).toBe("");
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT + 100);
         });
         expect(debouncedValue.textContent).toBe("test");
     }), 10000);
     it("should properly handle options object", () => __awaiter(void 0, void 0, void 0, function* () {
         function DebouncedComponent() {
-            const [count, setCount] = useState(0);
-            const [debouncedCount, setDebouncedCount] = useState(0);
+            const [count, setCount] = (0, react_1.useState)(0);
+            const [debouncedCount, setDebouncedCount] = (0, react_1.useState)(0);
             const options = {
                 edges: ["leading", "trailing"],
             };
-            const debouncedSetCount = useDebounce((value) => {
+            const debouncedSetCount = (0, useDebounce_1.useDebounce)((value) => {
                 setDebouncedCount(value);
             }, DEBOUNCE_WAIT, options);
-            return (React.createElement("div", null,
-                React.createElement("button", { "data-testid": "increment", onClick: () => {
+            return (react_1.default.createElement("div", null,
+                react_1.default.createElement("button", { "data-testid": "increment", onClick: () => {
                         const newCount = count + 1;
                         setCount(newCount);
                         debouncedSetCount(newCount);
                     }, type: "button" }, "Increment"),
-                React.createElement("div", { "data-testid": "count" }, count),
-                React.createElement("div", { "data-testid": "debounced-count" }, debouncedCount)));
+                react_1.default.createElement("div", { "data-testid": "count" }, count),
+                react_1.default.createElement("div", { "data-testid": "debounced-count" }, debouncedCount)));
         }
-        render(React.createElement(DebouncedComponent, null));
-        const incrementButton = screen.getByTestId("increment");
-        const debouncedCount = screen.getByTestId("debounced-count");
-        const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+        (0, react_2.render)(react_1.default.createElement(DebouncedComponent, null));
+        const incrementButton = react_2.screen.getByTestId("increment");
+        const debouncedCount = react_2.screen.getByTestId("debounced-count");
+        const user = user_event_1.default.setup({ advanceTimers: jest.advanceTimersByTime });
         yield user.click(incrementButton);
         // With leading edge, the value should be updated immediately
         expect(debouncedCount.textContent).toBe("1");
@@ -141,7 +169,7 @@ describe("useDebounce", () => {
         // Additional clicks shouldn't update immediately (debounced)
         expect(debouncedCount.textContent).toBe("1");
         // After the debounce period, the trailing edge should update with the latest value
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(debouncedCount.textContent).toBe("3");
@@ -149,12 +177,12 @@ describe("useDebounce", () => {
     it("should abort debounced function when signal is aborted", () => __awaiter(void 0, void 0, void 0, function* () {
         const mockFn = jest.fn();
         const controller = new AbortController();
-        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT, { signal: controller.signal }));
+        const { result } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, { signal: controller.signal }));
         result.current("test");
-        act(() => {
+        (0, react_2.act)(() => {
             controller.abort();
         });
-        act(() => {
+        (0, react_2.act)(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT + 100);
         });
         expect(mockFn).not.toHaveBeenCalled();

package/dist/useFocusTrap/index.js

@@ -1 +1,5 @@
-export { useFocusTrap } from "./useFocusTrap";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusTrap = void 0;
+var useFocusTrap_1 = require("./useFocusTrap");
+Object.defineProperty(exports, "useFocusTrap", { enumerable: true, get: function () { return useFocusTrap_1.useFocusTrap; } });

package/dist/useFocusTrap/useFocusTrap.js

@@ -1,4 +1,7 @@
-import { useEffect, useRef } from "react";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusTrap = useFocusTrap;
+const react_1 = require("react");
 /**
  * Traps the focus within the children of the ref element.
  *
@@ -7,11 +10,11 @@ import { useEffect, useRef } from "react";
  *
  * @returns ref
  */
-export function useFocusTrap(active) {
+function useFocusTrap(active) {
     // There's an ongoing issue with useRef return type clashing with an element's
     // ref prop type. TLDR: Use null because useRef doesn't expect undefined.
     // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/35572
-    const ref = useRef(null);
+    const ref = (0, react_1.useRef)(null);
     function handleKeyDown(event) {
         if (!(active && ref.current) || event.key !== "Tab") {
             return;
@@ -30,7 +33,7 @@ export function useFocusTrap(active) {
             }
         }
     }
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (active && ref.current) {
             const { firstElement } = getElements(ref.current);
             firstElement.focus();

package/dist/useFocusTrap/useFocusTrap.test.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,50 +8,54 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React from "react";
-import { render } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { useFocusTrap } from "./useFocusTrap";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_2 = require("@testing-library/react");
+const user_event_1 = __importDefault(require("@testing-library/user-event"));
+const useFocusTrap_1 = require("./useFocusTrap");
 const targetId = "target";
 const firstFocusableChild = "first-element";
 const lastFocusableChild = "last-element";
 it("should focus on the ref target on mount", () => {
-    const { getByTestId } = render(React.createElement(TestComponent, null));
+    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
     expect(getByTestId(targetId)).toHaveFocus();
 });
 it("should focus on the ref target when tabbing out of the last focusable element and ignore the tabindex'=-1'", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = render(React.createElement(TestComponent, null));
+    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
     getByTestId(lastFocusableChild).focus();
-    yield userEvent.tab();
+    yield user_event_1.default.tab();
     expect(getByTestId(targetId)).toHaveFocus();
 }));
 it("should focus on the first focusable element", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = render(React.createElement(TestComponent, null));
-    yield userEvent.tab();
+    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
+    yield user_event_1.default.tab();
     expect(getByTestId(firstFocusableChild)).toHaveFocus();
 }));
 it("should focus on the last focusable element", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = render(React.createElement(TestComponent, null));
-    yield userEvent.tab({ shift: true });
+    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
+    yield user_event_1.default.tab({ shift: true });
     expect(getByTestId(lastFocusableChild)).toHaveFocus();
 }));
 it("should not trap the tabbing and focus on the first child node", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = render(React.createElement(TestComponent, { trap: false }));
-    yield userEvent.tab();
+    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, { trap: false }));
+    yield user_event_1.default.tab();
     expect(getByTestId(targetId).previousElementSibling).toHaveFocus();
 }));
 function TestComponent({ trap = true }) {
-    const testRef = useFocusTrap(trap);
-    return (React.createElement(React.Fragment, null,
-        React.createElement("input", { type: "number" }),
-        React.createElement("div", { ref: testRef, "data-testid": targetId, tabIndex: 0 },
-            React.createElement("button", { "data-testid": firstFocusableChild }, "Click me"),
-            React.createElement("a", { href: "#" }),
-            React.createElement("input", { type: "text" }),
-            React.createElement("select", null,
-                React.createElement("option", { value: "A" })),
-            React.createElement("textarea", null),
-            React.createElement("span", { tabIndex: 0, "data-testId": lastFocusableChild }),
-            React.createElement("span", { tabIndex: -1 })),
-        React.createElement("input", { type: "calendar" })));
+    const testRef = (0, useFocusTrap_1.useFocusTrap)(trap);
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement("input", { type: "number" }),
+        react_1.default.createElement("div", { ref: testRef, "data-testid": targetId, tabIndex: 0 },
+            react_1.default.createElement("button", { "data-testid": firstFocusableChild }, "Click me"),
+            react_1.default.createElement("a", { href: "#" }),
+            react_1.default.createElement("input", { type: "text" }),
+            react_1.default.createElement("select", null,
+                react_1.default.createElement("option", { value: "A" })),
+            react_1.default.createElement("textarea", null),
+            react_1.default.createElement("span", { tabIndex: 0, "data-testId": lastFocusableChild }),
+            react_1.default.createElement("span", { tabIndex: -1 })),
+        react_1.default.createElement("input", { type: "calendar" })));
 }

package/dist/useFormState/index.js

@@ -1 +1,5 @@
-export { useFormState } from "./useFormState";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormState = void 0;
+var useFormState_1 = require("./useFormState");
+Object.defineProperty(exports, "useFormState", { enumerable: true, get: function () { return useFormState_1.useFormState; } });

package/dist/useFormState/useFormState.js

@@ -1,6 +1,9 @@
-import { useState } from "react";
-export function useFormState() {
-    const [formState, setFormState] = useState({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormState = useFormState;
+const react_1 = require("react");
+function useFormState() {
+    const [formState, setFormState] = (0, react_1.useState)({
         isDirty: false,
         isValid: false,
     });

package/dist/useInView/index.js

@@ -1 +1,17 @@
-export * from "./useInView";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useInView"), exports);

package/dist/useInView/useInView.js

@@ -1,9 +1,12 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-export function useInView() {
-    const ref = useRef(null);
-    const [isInView, setIsInView] = useState(false);
-    const handleIntersection = useCallback(entries => setIsInView(entries[0].isIntersecting), [setIsInView]);
-    useEffect(() => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInView = useInView;
+const react_1 = require("react");
+function useInView() {
+    const ref = (0, react_1.useRef)(null);
+    const [isInView, setIsInView] = (0, react_1.useState)(false);
+    const handleIntersection = (0, react_1.useCallback)(entries => setIsInView(entries[0].isIntersecting), [setIsInView]);
+    (0, react_1.useEffect)(() => {
         if (!window.IntersectionObserver)
             return;
         const observer = new IntersectionObserver(handleIntersection);

package/dist/useInView/useInView.test.js

@@ -1,24 +1,29 @@
-import React from "react";
-import { act, render, renderHook, screen } from "@testing-library/react";
-import { configMocks, mockIntersectionObserver } from "jsdom-testing-mocks";
-import { useInView } from "./useInView";
-configMocks({ act });
-const observer = mockIntersectionObserver();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_2 = require("@testing-library/react");
+const jsdom_testing_mocks_1 = require("jsdom-testing-mocks");
+const useInView_1 = require("./useInView");
+(0, jsdom_testing_mocks_1.configMocks)({ act: react_2.act });
+const observer = (0, jsdom_testing_mocks_1.mockIntersectionObserver)();
 describe("useInView", () => {
     it("should return true when the target element is in view", () => {
-        const { result, rerender } = renderHook(() => useInView());
+        const { result, rerender } = (0, react_2.renderHook)(() => (0, useInView_1.useInView)());
         const [ref, isInView] = result.current;
-        render(React.createElement("button", { ref: ref }));
+        (0, react_2.render)(react_1.default.createElement("button", { ref: ref }));
         rerender();
         expect(result.current[0].current).toBeInstanceOf(HTMLButtonElement);
-        observer.leaveNode(screen.getByRole("button"));
+        observer.leaveNode(react_2.screen.getByRole("button"));
         expect(isInView).toBe(false);
     });
     it("should return false when the target element is in view", () => {
-        const { result, rerender } = renderHook(() => useInView());
-        render(React.createElement("button", { ref: result.current[0] }));
+        const { result, rerender } = (0, react_2.renderHook)(() => (0, useInView_1.useInView)());
+        (0, react_2.render)(react_1.default.createElement("button", { ref: result.current[0] }));
         rerender();
-        observer.enterNode(screen.getByRole("button"));
+        observer.enterNode(react_2.screen.getByRole("button"));
         expect(result.current[1]).toBe(true);
     });
 });

package/dist/useIsMounted/index.js

@@ -1 +1,5 @@
-export { useIsMounted } from "./useIsMounted";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsMounted = void 0;
+var useIsMounted_1 = require("./useIsMounted");
+Object.defineProperty(exports, "useIsMounted", { enumerable: true, get: function () { return useIsMounted_1.useIsMounted; } });

package/dist/useIsMounted/useIsMounted.js

@@ -1,5 +1,8 @@
-import { useRef } from "react";
-import { useSafeLayoutEffect } from "../useSafeLayoutEffect";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsMounted = useIsMounted;
+const react_1 = require("react");
+const useSafeLayoutEffect_1 = require("../useSafeLayoutEffect");
 /**
  * If you are using this hook in order to only perform an action once after mounting (for example sending
  * analytics events), use `useOnMount` instead
@@ -19,9 +22,9 @@ import { useSafeLayoutEffect } from "../useSafeLayoutEffect";
  * When the component unmounts, it calls the cleanup function that sets `isMounted` to false.
  * This `useLayoutEffect` hook will only be run once.
  */
-export function useIsMounted() {
-    const isMounted = useRef(false);
-    useSafeLayoutEffect(() => {
+function useIsMounted() {
+    const isMounted = (0, react_1.useRef)(false);
+    (0, useSafeLayoutEffect_1.useSafeLayoutEffect)(() => {
         isMounted.current = true;
         return () => {
             isMounted.current = false;

package/dist/useIsMounted/useIsMounted.test.js

@@ -1,12 +1,14 @@
-import { renderHook } from "@testing-library/react-hooks";
-import { useIsMounted } from "./useIsMounted";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hooks_1 = require("@testing-library/react-hooks");
+const useIsMounted_1 = require("./useIsMounted");
 it("should return true when the component is currently mounted", () => {
-    const { result } = renderHook(() => useIsMounted());
+    const { result } = (0, react_hooks_1.renderHook)(() => (0, useIsMounted_1.useIsMounted)());
     const isMounted = result.current;
     expect(isMounted.current).toBe(true);
 });
 it("should return false when the component is unmounted", () => {
-    const { result, unmount } = renderHook(() => useIsMounted());
+    const { result, unmount } = (0, react_hooks_1.renderHook)(() => (0, useIsMounted_1.useIsMounted)());
     const isMounted = result.current;
     unmount();
     expect(isMounted.current).toBe(false);

package/dist/useLiveAnnounce/index.js

@@ -1 +1,5 @@
-export { useLiveAnnounce } from "./useLiveAnnounce";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLiveAnnounce = void 0;
+var useLiveAnnounce_1 = require("./useLiveAnnounce");
+Object.defineProperty(exports, "useLiveAnnounce", { enumerable: true, get: function () { return useLiveAnnounce_1.useLiveAnnounce; } });

package/dist/useLiveAnnounce/useLiveAnnounce.js

@@ -1,12 +1,15 @@
-import { useEffect, useState } from "react";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLiveAnnounce = useLiveAnnounce;
+const react_1 = require("react");
 /**
  * Announce a message on voice over whenever you do an action. This is
  * especially helpful when you have an action that adds or deletes an element
  * from the screen.
  */
-export function useLiveAnnounce() {
-    const [announcedMessage, setAnnouncedMessage] = useState("");
-    useEffect(() => {
+function useLiveAnnounce() {
+    const [announcedMessage, setAnnouncedMessage] = (0, react_1.useState)("");
+    (0, react_1.useEffect)(() => {
         let target;
         if (announcedMessage) {
             target = createAnnouncedElement();

package/dist/useLiveAnnounce/useLiveAnnounce.test.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,26 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import React from "react";
-import { act, render, screen, waitFor } from "@testing-library/react";
-import { useLiveAnnounce } from ".";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_2 = require("@testing-library/react");
+const _1 = require(".");
 function setupHook() {
     const returnVal = {
         liveAnnounce: jest.fn,
     };
     function TestComponent() {
-        Object.assign(returnVal, useLiveAnnounce());
-        return React.createElement(React.Fragment, null);
+        Object.assign(returnVal, (0, _1.useLiveAnnounce)());
+        return react_1.default.createElement(react_1.default.Fragment, null);
     }
-    const { rerender } = render(React.createElement(TestComponent, null));
-    return Object.assign(Object.assign({}, returnVal), { rerenderComponent: () => rerender(React.createElement(TestComponent, null)) });
+    const { rerender } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
+    return Object.assign(Object.assign({}, returnVal), { rerenderComponent: () => rerender(react_1.default.createElement(TestComponent, null)) });
 }
 it("should render a div to announce", () => __awaiter(void 0, void 0, void 0, function* () {
     const { liveAnnounce } = setupHook();
     const message = "Huzzah";
-    act(() => liveAnnounce(message));
-    yield waitFor(() => {
-        const expectedElement = screen.queryByRole("status");
+    (0, react_2.act)(() => liveAnnounce(message));
+    yield (0, react_2.waitFor)(() => {
+        const expectedElement = react_2.screen.queryByRole("status");
         expect(expectedElement).toBeInTheDocument();
         expect(expectedElement === null || expectedElement === void 0 ? void 0 : expectedElement.textContent).toBe(message);
         expect(expectedElement).toHaveAttribute("role", "status");
@@ -36,20 +41,20 @@ it("should render a div to announce", () => __awaiter(void 0, void 0, void 0, fu
 }));
 it("should not render the announced div", () => __awaiter(void 0, void 0, void 0, function* () {
     setupHook();
-    expect(screen.queryByRole("status")).not.toBeInTheDocument();
+    expect(react_2.screen.queryByRole("status")).not.toBeInTheDocument();
 }));
 it("should only have 1 div to announce a message on a single instance of the hook", () => __awaiter(void 0, void 0, void 0, function* () {
     const { liveAnnounce } = setupHook();
     const firstMessage = "I am first";
     const secondMessage = "I am second";
-    act(() => liveAnnounce(firstMessage));
-    yield waitFor(() => {
-        expect(screen.queryAllByRole("status")).toHaveLength(1);
-        expect(screen.getByRole("status").textContent).toBe(firstMessage);
+    (0, react_2.act)(() => liveAnnounce(firstMessage));
+    yield (0, react_2.waitFor)(() => {
+        expect(react_2.screen.queryAllByRole("status")).toHaveLength(1);
+        expect(react_2.screen.getByRole("status").textContent).toBe(firstMessage);
     });
-    act(() => liveAnnounce(secondMessage));
-    yield waitFor(() => {
-        expect(screen.queryAllByRole("status")).toHaveLength(1);
-        expect(screen.getByRole("status").textContent).toBe(secondMessage);
+    (0, react_2.act)(() => liveAnnounce(secondMessage));
+    yield (0, react_2.waitFor)(() => {
+        expect(react_2.screen.queryAllByRole("status")).toHaveLength(1);
+        expect(react_2.screen.getByRole("status").textContent).toBe(secondMessage);
     });
 }));

package/dist/useOnKeyDown/index.js

@@ -1 +1,5 @@
-export { useOnKeyDown } from "./useOnKeyDown";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnKeyDown = void 0;
+var useOnKeyDown_1 = require("./useOnKeyDown");
+Object.defineProperty(exports, "useOnKeyDown", { enumerable: true, get: function () { return useOnKeyDown_1.useOnKeyDown; } });

package/dist/useOnKeyDown/useOnKeyDown.js

@@ -1,6 +1,9 @@
-import { useEffect } from "react";
-export function useOnKeyDown(callback, keys) {
-    useEffect(() => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnKeyDown = useOnKeyDown;
+const react_1 = require("react");
+function useOnKeyDown(callback, keys) {
+    (0, react_1.useEffect)(() => {
         window.addEventListener("keydown", handler);
         return () => {
             window.removeEventListener("keydown", handler);