@jobber/hooks 2.17.1 → 2.17.2

package/dist/useDebounce/useDebounce.test.js

@@ -1,27 +1,3 @@
-"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) {
@@ -31,14 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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");
+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";
 const DEBOUNCE_WAIT = 300;
 describe("useDebounce", () => {
     beforeEach(() => {
@@ -49,10 +21,10 @@ describe("useDebounce", () => {
     });
     it("should debounce the function call", () => __awaiter(void 0, void 0, void 0, function* () {
         const mockFn = jest.fn();
-        const { result } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
+        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
         result.current("test");
         expect(mockFn).not.toHaveBeenCalled();
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).toHaveBeenCalledWith("test");
@@ -60,23 +32,23 @@ describe("useDebounce", () => {
     }));
     it("should cancel pending debounced calls on unmount", () => {
         const mockFn = jest.fn();
-        const { result, unmount } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
+        const { result, unmount } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
         result.current("test");
         unmount();
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).not.toHaveBeenCalled();
     });
     it("should handle multiple calls within the debounce period", () => {
         const mockFn = jest.fn();
-        const { result } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT));
+        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT));
         result.current("first");
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT / 2);
         });
         result.current("second");
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(mockFn).toHaveBeenCalledTimes(1);
@@ -86,7 +58,7 @@ describe("useDebounce", () => {
         const mockFn = jest.fn();
         const debounceEgdesOption = ["trailing"];
         // Use a function that returns a new options object each time
-        const { result, rerender } = (0, react_2.renderHook)(({ options }) => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
+        const { result, rerender } = renderHook(({ options }) => useDebounce(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
         const debounceRef = result.current;
         rerender({ options: { edges: debounceEgdesOption } });
         expect(debounceRef).toBe(result.current);
@@ -98,16 +70,16 @@ describe("useDebounce", () => {
         // Start with trailing edge
         const debounceEgdesOption = ["trailing"];
         // Use a function that returns a new options object each time
-        const { result, rerender } = (0, react_2.renderHook)(({ options }) => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
+        const { result, rerender } = renderHook(({ options }) => useDebounce(mockFn, DEBOUNCE_WAIT, options), { initialProps: { options: { edges: debounceEgdesOption } } });
         result.current("first");
-        (0, react_2.act)(() => {
+        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");
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(TIME_INCREMENT_LESSER_THAN_DEBOUNCE_WAIT);
         });
         // The config change should be ignored, options are hardcoded
@@ -115,52 +87,52 @@ describe("useDebounce", () => {
     });
     it("should work with React components", () => __awaiter(void 0, void 0, void 0, function* () {
         function DebouncedComponent() {
-            const [value, setValue] = (0, react_1.useState)("");
-            const [debouncedValue, setDebouncedValue] = (0, react_1.useState)("");
-            const debouncedSetValue = (0, useDebounce_1.useDebounce)((newValue) => {
+            const [value, setValue] = useState("");
+            const [debouncedValue, setDebouncedValue] = useState("");
+            const debouncedSetValue = useDebounce((newValue) => {
                 setDebouncedValue(newValue);
             }, DEBOUNCE_WAIT);
-            (0, react_1.useEffect)(() => {
+            useEffect(() => {
                 debouncedSetValue(value);
             }, [value, debouncedSetValue]);
-            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)));
+            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)));
         }
-        (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 });
+        render(React.createElement(DebouncedComponent, null));
+        const input = screen.getByTestId("input");
+        const debouncedValue = screen.getByTestId("debounced-value");
+        const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
         yield user.type(input, "test");
         expect(debouncedValue.textContent).toBe("");
-        (0, react_2.act)(() => {
+        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] = (0, react_1.useState)(0);
-            const [debouncedCount, setDebouncedCount] = (0, react_1.useState)(0);
+            const [count, setCount] = useState(0);
+            const [debouncedCount, setDebouncedCount] = useState(0);
             const options = {
                 edges: ["leading", "trailing"],
             };
-            const debouncedSetCount = (0, useDebounce_1.useDebounce)((value) => {
+            const debouncedSetCount = useDebounce((value) => {
                 setDebouncedCount(value);
             }, DEBOUNCE_WAIT, options);
-            return (react_1.default.createElement("div", null,
-                react_1.default.createElement("button", { "data-testid": "increment", onClick: () => {
+            return (React.createElement("div", null,
+                React.createElement("button", { "data-testid": "increment", onClick: () => {
                         const newCount = count + 1;
                         setCount(newCount);
                         debouncedSetCount(newCount);
                     }, type: "button" }, "Increment"),
-                react_1.default.createElement("div", { "data-testid": "count" }, count),
-                react_1.default.createElement("div", { "data-testid": "debounced-count" }, debouncedCount)));
+                React.createElement("div", { "data-testid": "count" }, count),
+                React.createElement("div", { "data-testid": "debounced-count" }, debouncedCount)));
         }
-        (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 });
+        render(React.createElement(DebouncedComponent, null));
+        const incrementButton = screen.getByTestId("increment");
+        const debouncedCount = screen.getByTestId("debounced-count");
+        const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
         yield user.click(incrementButton);
         // With leading edge, the value should be updated immediately
         expect(debouncedCount.textContent).toBe("1");
@@ -169,7 +141,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
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT);
         });
         expect(debouncedCount.textContent).toBe("3");
@@ -177,12 +149,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 } = (0, react_2.renderHook)(() => (0, useDebounce_1.useDebounce)(mockFn, DEBOUNCE_WAIT, { signal: controller.signal }));
+        const { result } = renderHook(() => useDebounce(mockFn, DEBOUNCE_WAIT, { signal: controller.signal }));
         result.current("test");
-        (0, react_2.act)(() => {
+        act(() => {
             controller.abort();
         });
-        (0, react_2.act)(() => {
+        act(() => {
             jest.advanceTimersByTime(DEBOUNCE_WAIT + 100);
         });
         expect(mockFn).not.toHaveBeenCalled();

package/dist/useFocusTrap/index.js

@@ -1,5 +1 @@
-"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; } });
+export { useFocusTrap } from "./useFocusTrap";

package/dist/useFocusTrap/useFocusTrap.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFocusTrap = useFocusTrap;
-const react_1 = require("react");
+import { useEffect, useRef } from "react";
 /**
  * Traps the focus within the children of the ref element.
  *
@@ -10,11 +7,11 @@ const react_1 = require("react");
  *
  * @returns ref
  */
-function useFocusTrap(active) {
+export 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 = (0, react_1.useRef)(null);
+    const ref = useRef(null);
     function handleKeyDown(event) {
         if (!(active && ref.current) || event.key !== "Tab") {
             return;
@@ -33,7 +30,7 @@ function useFocusTrap(active) {
             }
         }
     }
-    (0, react_1.useEffect)(() => {
+    useEffect(() => {
         if (active && ref.current) {
             const { firstElement } = getElements(ref.current);
             firstElement.focus();

package/dist/useFocusTrap/useFocusTrap.test.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,54 +7,50 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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");
+import React from "react";
+import { render } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { useFocusTrap } from "./useFocusTrap";
 const targetId = "target";
 const firstFocusableChild = "first-element";
 const lastFocusableChild = "last-element";
 it("should focus on the ref target on mount", () => {
-    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
+    const { getByTestId } = render(React.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 } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
+    const { getByTestId } = render(React.createElement(TestComponent, null));
     getByTestId(lastFocusableChild).focus();
-    yield user_event_1.default.tab();
+    yield userEvent.tab();
     expect(getByTestId(targetId)).toHaveFocus();
 }));
 it("should focus on the first focusable element", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
-    yield user_event_1.default.tab();
+    const { getByTestId } = render(React.createElement(TestComponent, null));
+    yield userEvent.tab();
     expect(getByTestId(firstFocusableChild)).toHaveFocus();
 }));
 it("should focus on the last focusable element", () => __awaiter(void 0, void 0, void 0, function* () {
-    const { getByTestId } = (0, react_2.render)(react_1.default.createElement(TestComponent, null));
-    yield user_event_1.default.tab({ shift: true });
+    const { getByTestId } = render(React.createElement(TestComponent, null));
+    yield userEvent.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 } = (0, react_2.render)(react_1.default.createElement(TestComponent, { trap: false }));
-    yield user_event_1.default.tab();
+    const { getByTestId } = render(React.createElement(TestComponent, { trap: false }));
+    yield userEvent.tab();
     expect(getByTestId(targetId).previousElementSibling).toHaveFocus();
 }));
 function TestComponent({ trap = true }) {
-    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" })));
+    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" })));
 }

package/dist/useFormState/index.js

@@ -1,5 +1 @@
-"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; } });
+export { useFormState } from "./useFormState";

package/dist/useFormState/useFormState.js

@@ -1,9 +1,6 @@
-"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)({
+import { useState } from "react";
+export function useFormState() {
+    const [formState, setFormState] = useState({
         isDirty: false,
         isValid: false,
     });

package/dist/useInView/index.js

@@ -1,17 +1 @@
-"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);
+export * from "./useInView";

package/dist/useInView/useInView.js

@@ -1,12 +1,9 @@
-"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)(() => {
+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(() => {
         if (!window.IntersectionObserver)
             return;
         const observer = new IntersectionObserver(handleIntersection);

package/dist/useInView/useInView.test.js

@@ -1,29 +1,24 @@
-"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)();
+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();
 describe("useInView", () => {
     it("should return true when the target element is in view", () => {
-        const { result, rerender } = (0, react_2.renderHook)(() => (0, useInView_1.useInView)());
+        const { result, rerender } = renderHook(() => useInView());
         const [ref, isInView] = result.current;
-        (0, react_2.render)(react_1.default.createElement("button", { ref: ref }));
+        render(React.createElement("button", { ref: ref }));
         rerender();
         expect(result.current[0].current).toBeInstanceOf(HTMLButtonElement);
-        observer.leaveNode(react_2.screen.getByRole("button"));
+        observer.leaveNode(screen.getByRole("button"));
         expect(isInView).toBe(false);
     });
     it("should return false when the target element is in view", () => {
-        const { result, rerender } = (0, react_2.renderHook)(() => (0, useInView_1.useInView)());
-        (0, react_2.render)(react_1.default.createElement("button", { ref: result.current[0] }));
+        const { result, rerender } = renderHook(() => useInView());
+        render(React.createElement("button", { ref: result.current[0] }));
         rerender();
-        observer.enterNode(react_2.screen.getByRole("button"));
+        observer.enterNode(screen.getByRole("button"));
         expect(result.current[1]).toBe(true);
     });
 });

package/dist/useIsMounted/index.js

@@ -1,5 +1 @@
-"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; } });
+export { useIsMounted } from "./useIsMounted";

package/dist/useIsMounted/useIsMounted.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useIsMounted = useIsMounted;
-const react_1 = require("react");
-const useSafeLayoutEffect_1 = require("../useSafeLayoutEffect");
+import { useRef } from "react";
+import { useSafeLayoutEffect } from "../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
@@ -22,9 +19,9 @@ const useSafeLayoutEffect_1 = require("../useSafeLayoutEffect");
  * When the component unmounts, it calls the cleanup function that sets `isMounted` to false.
  * This `useLayoutEffect` hook will only be run once.
  */
-function useIsMounted() {
-    const isMounted = (0, react_1.useRef)(false);
-    (0, useSafeLayoutEffect_1.useSafeLayoutEffect)(() => {
+export function useIsMounted() {
+    const isMounted = useRef(false);
+    useSafeLayoutEffect(() => {
         isMounted.current = true;
         return () => {
             isMounted.current = false;

package/dist/useIsMounted/useIsMounted.test.js

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

package/dist/useLiveAnnounce/index.js

@@ -1,5 +1 @@
-"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; } });
+export { useLiveAnnounce } from "./useLiveAnnounce";

package/dist/useLiveAnnounce/useLiveAnnounce.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLiveAnnounce = useLiveAnnounce;
-const react_1 = require("react");
+import { useEffect, useState } from "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.
  */
-function useLiveAnnounce() {
-    const [announcedMessage, setAnnouncedMessage] = (0, react_1.useState)("");
-    (0, react_1.useEffect)(() => {
+export function useLiveAnnounce() {
+    const [announcedMessage, setAnnouncedMessage] = useState("");
+    useEffect(() => {
         let target;
         if (announcedMessage) {
             target = createAnnouncedElement();

package/dist/useLiveAnnounce/useLiveAnnounce.test.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,30 +7,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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(".");
+import React from "react";
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { useLiveAnnounce } from ".";
 function setupHook() {
     const returnVal = {
         liveAnnounce: jest.fn,
     };
     function TestComponent() {
-        Object.assign(returnVal, (0, _1.useLiveAnnounce)());
-        return react_1.default.createElement(react_1.default.Fragment, null);
+        Object.assign(returnVal, useLiveAnnounce());
+        return React.createElement(React.Fragment, 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)) });
+    const { rerender } = render(React.createElement(TestComponent, null));
+    return Object.assign(Object.assign({}, returnVal), { rerenderComponent: () => rerender(React.createElement(TestComponent, null)) });
 }
 it("should render a div to announce", () => __awaiter(void 0, void 0, void 0, function* () {
     const { liveAnnounce } = setupHook();
     const message = "Huzzah";
-    (0, react_2.act)(() => liveAnnounce(message));
-    yield (0, react_2.waitFor)(() => {
-        const expectedElement = react_2.screen.queryByRole("status");
+    act(() => liveAnnounce(message));
+    yield waitFor(() => {
+        const expectedElement = screen.queryByRole("status");
         expect(expectedElement).toBeInTheDocument();
         expect(expectedElement === null || expectedElement === void 0 ? void 0 : expectedElement.textContent).toBe(message);
         expect(expectedElement).toHaveAttribute("role", "status");
@@ -41,20 +36,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(react_2.screen.queryByRole("status")).not.toBeInTheDocument();
+    expect(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";
-    (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(firstMessage));
+    yield waitFor(() => {
+        expect(screen.queryAllByRole("status")).toHaveLength(1);
+        expect(screen.getByRole("status").textContent).toBe(firstMessage);
     });
-    (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);
+    act(() => liveAnnounce(secondMessage));
+    yield waitFor(() => {
+        expect(screen.queryAllByRole("status")).toHaveLength(1);
+        expect(screen.getByRole("status").textContent).toBe(secondMessage);
     });
 }));

package/dist/useOnKeyDown/index.js

@@ -1,5 +1 @@
-"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; } });
+export { useOnKeyDown } from "./useOnKeyDown";

package/dist/useOnKeyDown/useOnKeyDown.js

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