@jobber/components 4.91.2-retheme-fe.1 → 4.91.2-retheme-fe.3

package/dist/tslib.es6-6dmIhJTi.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;
+exports.__generator = __generator;
+exports.__rest = __rest;
+exports.__spread = __spread;

package/dist/tslib.es6-sBHgrKO6.js

@@ -0,0 +1,97 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+/** @deprecated */
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __rest as _, __awaiter as a, __generator as b, __spread as c };

package/dist/useActiveLayout-EZ1eunvS.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var useResponsiveSizing = require('./useResponsiveSizing--fEPoUpK.js');
+var DataListContext = require('./DataListContext-CtxUHHfs.js');
+
+function useActiveLayout() {
+    const { layoutBreakpoints, layouts } = DataListContext.useDataListContext();
+    const breakpoints = useResponsiveSizing.useResponsiveSizing();
+    const reversedLayoutBreakpoints = [...layoutBreakpoints].reverse();
+    const activeBreakpoint = reversedLayoutBreakpoints.find(key => breakpoints[key]) ||
+        layoutBreakpoints[0];
+    const layout = layouts[activeBreakpoint];
+    return { layout, activeBreakpoint };
+}
+
+exports.useActiveLayout = useActiveLayout;

package/dist/useActiveLayout-VN6ZOkxZ.js

@@ -0,0 +1,14 @@
+import { u as useResponsiveSizing } from './useResponsiveSizing-Dh343Vot.js';
+import { u as useDataListContext } from './DataListContext-B9QPGTE9.js';
+
+function useActiveLayout() {
+    const { layoutBreakpoints, layouts } = useDataListContext();
+    const breakpoints = useResponsiveSizing();
+    const reversedLayoutBreakpoints = [...layoutBreakpoints].reverse();
+    const activeBreakpoint = reversedLayoutBreakpoints.find(key => breakpoints[key]) ||
+        layoutBreakpoints[0];
+    const layout = layouts[activeBreakpoint];
+    return { layout, activeBreakpoint };
+}
+
+export { useActiveLayout as u };

package/dist/useAssert-BHj1OQqJ.js

@@ -0,0 +1,27 @@
+import { a as getAugmentedNamespace, c as commonjsGlobal } from './_commonjsHelpers-jBnpF2iq.js';
+import { _ as _polyfillNode_process } from './_polyfill-node.process-SftmnXC5.js';
+
+var useAssert$1 = {};
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_process);
+
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(useAssert$1, "__esModule", { value: true });
+var useAssert_2 = useAssert$1.useAssert = void 0;
+const process_1 = __importDefault(require$$0);
+function useAssert(shouldShow, message, options) {
+    var _a;
+    if (((_a = process_1.default === null || process_1.default === void 0 ? void 0 : process_1.default.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) !== "production" && shouldShow) {
+        if (options === null || options === void 0 ? void 0 : options.warn) {
+            console.warn(message);
+        }
+        else {
+            throw new Error(message);
+        }
+    }
+}
+useAssert_2 = useAssert$1.useAssert = useAssert;
+
+export { useAssert_2 as u };

package/dist/useAssert-knwpkZW0.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-DAuvc7SO.js');
+var _polyfillNode_process = require('./_polyfill-node.process-DT4I8V6P.js');
+
+var useAssert$1 = {};
+
+var require$$0 = /*@__PURE__*/_commonjsHelpers.getAugmentedNamespace(_polyfillNode_process._polyfillNode_process);
+
+var __importDefault = (_commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(useAssert$1, "__esModule", { value: true });
+exports.useAssert_2 = useAssert$1.useAssert = void 0;
+const process_1 = __importDefault(require$$0);
+function useAssert(shouldShow, message, options) {
+    var _a;
+    if (((_a = process_1.default === null || process_1.default === void 0 ? void 0 : process_1.default.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV) !== "production" && shouldShow) {
+        if (options === null || options === void 0 ? void 0 : options.warn) {
+            console.warn(message);
+        }
+        else {
+            throw new Error(message);
+        }
+    }
+}
+exports.useAssert_2 = useAssert$1.useAssert = useAssert;

package/dist/useBatchSelect-BTQ9PbXi.js

@@ -0,0 +1,36 @@
+import { u as useDataListContext } from './DataListContext-B9QPGTE9.js';
+
+function useBatchSelect() {
+    const { selected, onSelect, onSelectAll } = useDataListContext();
+    const isArray = Array.isArray(selected);
+    const selectedIDs = getIDs(selected);
+    const isSelectAll = !isArray;
+    return {
+        canSelect: Boolean(selected && onSelect),
+        canSelectAll: Boolean(onSelect && onSelectAll),
+        hasAtLeastOneSelected: isSelectAll || selectedIDs.length > 0,
+        isSelectAll,
+        isSelectSome: isArray,
+        selectedCount: getSelectedCount(selected),
+        selectedIDs,
+        selected,
+        onSelect,
+        onSelectAll,
+    };
+}
+function getIDs(selected) {
+    if (Array.isArray(selected))
+        return selected;
+    if (selected === undefined)
+        return [];
+    return selected.unselected;
+}
+function getSelectedCount(selected) {
+    if (Array.isArray(selected))
+        return selected.length;
+    if (selected === undefined)
+        return 0;
+    return selected.totalCount - selected.unselected.length;
+}
+
+export { useBatchSelect as u };

package/dist/useBatchSelect-C9775spd.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var DataListContext = require('./DataListContext-CtxUHHfs.js');
+
+function useBatchSelect() {
+    const { selected, onSelect, onSelectAll } = DataListContext.useDataListContext();
+    const isArray = Array.isArray(selected);
+    const selectedIDs = getIDs(selected);
+    const isSelectAll = !isArray;
+    return {
+        canSelect: Boolean(selected && onSelect),
+        canSelectAll: Boolean(onSelect && onSelectAll),
+        hasAtLeastOneSelected: isSelectAll || selectedIDs.length > 0,
+        isSelectAll,
+        isSelectSome: isArray,
+        selectedCount: getSelectedCount(selected),
+        selectedIDs,
+        selected,
+        onSelect,
+        onSelectAll,
+    };
+}
+function getIDs(selected) {
+    if (Array.isArray(selected))
+        return selected;
+    if (selected === undefined)
+        return [];
+    return selected.unselected;
+}
+function getSelectedCount(selected) {
+    if (Array.isArray(selected))
+        return selected.length;
+    if (selected === undefined)
+        return 0;
+    return selected.totalCount - selected.unselected.length;
+}
+
+exports.useBatchSelect = useBatchSelect;

package/dist/useChildComponent-BLLL1r7O.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var React = require('react');
+
+/**
+ * Returns the first React Child that receives `true` from isCorrectComponent
+ * @param children React Children
+ * @param isCorrectComponent a function that accepts a JSX Element and returns a boolean.
+ * @returns The first child component that returns true on isCorrectComponent
+ */
+function useChildComponent(children, isCorrectComponent) {
+    return React.useMemo(() => {
+        return React.Children.toArray(children).find(d => React.isValidElement(d) && isCorrectComponent(d));
+    }, [children]);
+}
+
+exports.useChildComponent = useChildComponent;

package/dist/useChildComponent-D9yXvtJR.js

@@ -0,0 +1,15 @@
+import React, { useMemo, isValidElement } from 'react';
+
+/**
+ * Returns the first React Child that receives `true` from isCorrectComponent
+ * @param children React Children
+ * @param isCorrectComponent a function that accepts a JSX Element and returns a boolean.
+ * @returns The first child component that returns true on isCorrectComponent
+ */
+function useChildComponent(children, isCorrectComponent) {
+    return useMemo(() => {
+        return React.Children.toArray(children).find(d => isValidElement(d) && isCorrectComponent(d));
+    }, [children]);
+}
+
+export { useChildComponent as u };

package/dist/useFocusTrap-B8ok2cIh.js

@@ -0,0 +1,74 @@
+import React from 'react';
+
+var useFocusTrap$1 = {};
+
+Object.defineProperty(useFocusTrap$1, "__esModule", { value: true });
+var useFocusTrap_2 = useFocusTrap$1.useFocusTrap = void 0;
+const react_1 = React;
+/**
+ * Traps the focus within the children of the ref element.
+ *
+ * @param active - Turns the focus trapping on or off. Also adds aria-hidden on the
+ * body but not the dialog.
+ *
+ * @returns ref
+ */
+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);
+    function handleKeyDown(event) {
+        if (!(active && ref.current) || event.key !== "Tab") {
+            return;
+        }
+        const { firstElement, lastElement } = getElements(ref.current);
+        if (event.shiftKey) {
+            if (document.activeElement === firstElement) {
+                lastElement.focus();
+                event.preventDefault();
+            }
+        }
+        else {
+            if (document.activeElement === lastElement) {
+                firstElement.focus();
+                event.preventDefault();
+            }
+        }
+    }
+    (0, react_1.useEffect)(() => {
+        if (active && ref.current) {
+            const { firstElement } = getElements(ref.current);
+            firstElement.focus();
+            ref.current.addEventListener("keydown", handleKeyDown);
+        }
+        return () => {
+            var _a;
+            (_a = ref.current) === null || _a === void 0 ? void 0 : _a.removeEventListener("keydown", handleKeyDown);
+        };
+    }, [active]);
+    return ref;
+}
+useFocusTrap_2 = useFocusTrap$1.useFocusTrap = useFocusTrap;
+function getElements(ref) {
+    const focusables = [
+        "button",
+        "[href]",
+        "input",
+        "select",
+        "textarea",
+        '[tabindex]:not([tabindex="-1"])',
+    ];
+    const elements = [
+        ...ref.querySelectorAll(focusables.join(", ")),
+    ];
+    // If the ref is focusable, ensure it's the first element to be focused.
+    if (ref.getAttribute("tabindex") === "0") {
+        elements.unshift(ref);
+    }
+    const firstElement = elements[0];
+    const lastElement = elements[elements.length - 1];
+    return { firstElement, lastElement };
+}
+
+export { useFocusTrap_2 as u };

package/dist/useFocusTrap-BBkfWfEx.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var React = require('react');
+
+var useFocusTrap$1 = {};
+
+Object.defineProperty(useFocusTrap$1, "__esModule", { value: true });
+exports.useFocusTrap_2 = useFocusTrap$1.useFocusTrap = void 0;
+const react_1 = React;
+/**
+ * Traps the focus within the children of the ref element.
+ *
+ * @param active - Turns the focus trapping on or off. Also adds aria-hidden on the
+ * body but not the dialog.
+ *
+ * @returns ref
+ */
+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);
+    function handleKeyDown(event) {
+        if (!(active && ref.current) || event.key !== "Tab") {
+            return;
+        }
+        const { firstElement, lastElement } = getElements(ref.current);
+        if (event.shiftKey) {
+            if (document.activeElement === firstElement) {
+                lastElement.focus();
+                event.preventDefault();
+            }
+        }
+        else {
+            if (document.activeElement === lastElement) {
+                firstElement.focus();
+                event.preventDefault();
+            }
+        }
+    }
+    (0, react_1.useEffect)(() => {
+        if (active && ref.current) {
+            const { firstElement } = getElements(ref.current);
+            firstElement.focus();
+            ref.current.addEventListener("keydown", handleKeyDown);
+        }
+        return () => {
+            var _a;
+            (_a = ref.current) === null || _a === void 0 ? void 0 : _a.removeEventListener("keydown", handleKeyDown);
+        };
+    }, [active]);
+    return ref;
+}
+exports.useFocusTrap_2 = useFocusTrap$1.useFocusTrap = useFocusTrap;
+function getElements(ref) {
+    const focusables = [
+        "button",
+        "[href]",
+        "input",
+        "select",
+        "textarea",
+        '[tabindex]:not([tabindex="-1"])',
+    ];
+    const elements = [
+        ...ref.querySelectorAll(focusables.join(", ")),
+    ];
+    // If the ref is focusable, ensure it's the first element to be focused.
+    if (ref.getAttribute("tabindex") === "0") {
+        elements.unshift(ref);
+    }
+    const firstElement = elements[0];
+    const lastElement = elements[elements.length - 1];
+    return { firstElement, lastElement };
+}

package/dist/useInView-Bj_Jl5Bw.js

@@ -0,0 +1,25 @@
+import React from 'react';
+
+var useInView$1 = {};
+
+Object.defineProperty(useInView$1, "__esModule", { value: true });
+var useInView_2 = useInView$1.useInView = void 0;
+const react_1 = 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);
+        ref.current && observer.observe(ref.current);
+        return () => {
+            ref.current && observer.unobserve(ref.current);
+        };
+    }, [handleIntersection, ref.current]);
+    return [ref, isInView];
+}
+useInView_2 = useInView$1.useInView = useInView;
+
+export { useInView_2 as u };

package/dist/useInView-fsT3lwCU.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var React = require('react');
+
+var useInView$1 = {};
+
+Object.defineProperty(useInView$1, "__esModule", { value: true });
+exports.useInView_2 = useInView$1.useInView = void 0;
+const react_1 = 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);
+        ref.current && observer.observe(ref.current);
+        return () => {
+            ref.current && observer.unobserve(ref.current);
+        };
+    }, [handleIntersection, ref.current]);
+    return [ref, isInView];
+}
+exports.useInView_2 = useInView$1.useInView = useInView;

package/dist/useIsMounted-CYEXH1zH.js

@@ -0,0 +1,47 @@
+import React from 'react';
+import { a as useSafeLayoutEffect$1 } from './useSafeLayoutEffect-BQD8SqX2.js';
+
+var useIsMounted$1 = {};
+
+var useSafeLayoutEffect = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.useSafeLayoutEffect = void 0;
+	var useSafeLayoutEffect_1 = useSafeLayoutEffect$1;
+	Object.defineProperty(exports, "useSafeLayoutEffect", { enumerable: true, get: function () { return useSafeLayoutEffect_1.useSafeLayoutEffect; } }); 
+} (useSafeLayoutEffect));
+
+Object.defineProperty(useIsMounted$1, "__esModule", { value: true });
+var useIsMounted_2 = useIsMounted$1.useIsMounted = void 0;
+const react_1 = React;
+const useSafeLayoutEffect_1 = useSafeLayoutEffect;
+/**
+ * Why does this work?
+ *
+ * The following is from the react docs:
+ *    [The return function from `useLayoutEffect`] is the optional cleanup mechanism for effects.
+ *    Every effect may return a function that cleans up after it.
+ *
+ *    When exactly does React clean up an effect? React performs the cleanup when the component unmounts.
+ *    The cleanup for useLayoutEffect is called after component unmounts and before before browser painting
+ *    the screen
+ *
+ * What does that mean for us? When this hook is initially loaded, we then trigger a `useLayoutEffect` that
+ * sets the isMounted to true right after the component is mounted.
+ * 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)(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return isMounted;
+}
+useIsMounted_2 = useIsMounted$1.useIsMounted = useIsMounted;
+
+export { useIsMounted_2 as u };