@koine/react 2.0.0-beta.2 → 2.0.0-beta.20

package/{hooks/useDateLocale.mjs → useDateLocale.js}

@@ -1,33 +1,24 @@
-import { __awaiter, __generator } from "tslib";
+import { __awaiter, __generator, __read } from "tslib";
 import { useEffect, useState } from "react";
-/**
- * Dynamically import the date-fns correct locale
- *
- * Inspired by:
- * @see https://robertmarshall.dev/blog/dynamically-import-datefns-locale-mui-datepicker-localization/
- */
 export function useDateLocale(locale, defaultLocale) {
     var _this = this;
     if (defaultLocale === void 0) { defaultLocale = "en"; }
-    var _a = useState(), data = _a[0], setData = _a[1];
-    var _b = useState(defaultLocale), current = _b[0], setCurrent = _b[1];
-    // const [ready, setReady] = useState(false);
-    // If the user changes the locale listen to the change and import the locale that is now required.
+    var _a = __read(useState(), 2), data = _a[0], setData = _a[1];
+    var _b = __read(useState(defaultLocale), 2), current = _b[0], setCurrent = _b[1];
     useEffect(function () {
         var importLocaleFile = function () { return __awaiter(_this, void 0, void 0, function () {
             var localeToSet;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, import("date-fns/locale/en-US/index.js")];
+                    case 0: return [4, import("date-fns/locale/en-US/index.js")];
                     case 1:
                         localeToSet = _a.sent();
                         setCurrent(locale || current);
                         setData(localeToSet.default);
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         }); };
-        // If the locale has not yet been loaded.
         if (locale !== current) {
             importLocaleFile();
         }

package/useFirstMountState.d.ts

@@ -0,0 +1,2 @@
+export declare function useFirstMountState(): boolean;
+export default useFirstMountState;

package/{hooks/useFirstMountState.mjs → useFirstMountState.js}

@@ -1,7 +1,4 @@
 import { useRef } from "react";
-/**
- * @borrows [streamich/react-use](https://github.com/streamich/react-use/blob/master/src/useFirstMountState.ts)
- */
 export function useFirstMountState() {
     var isFirst = useRef(true);
     if (isFirst.current) {

package/useFixedOffset.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare function useFixedOffset(selector?: string): import("react").MutableRefObject<number>;
+export default useFixedOffset;

package/{hooks/useFixedOffset.mjs → useFixedOffset.js}

@@ -1,35 +1,20 @@
 import { useRef } from "react";
-import injectCss from "@koine/dom/injectCss";
-import calculateFixedOffset from "@koine/dom/calculateFixedOffset";
-import listenResizeDebounced from "@koine/dom/listenResizeDebounced";
-import $each from "@koine/dom/$each";
-import debounce from "@koine/utils/debounce";
-import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect";
+import { debounce } from "@koine/utils";
+import { $each, calculateFixedOffset, injectCss, listenResizeDebounced, } from "@koine/dom";
+import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect.js";
 var inject = function (value) {
     injectCss("useFixedOffset", "html{scroll-padding-top: ".concat(value, "px}"));
 };
-/**
- * # Use fixed offset
- *
- * Maybe use [ResizeObserver polyfill](https://github.com/juggle/resize-observer)
- *
- * @see https://web.dev/resize-observer/
- *
- * @param selector By default `[data-fixed]`: anyhting with the data attribute `data-fixed`
- */
 export function useFixedOffset(selector) {
     var fixedOffset = useRef(0);
     useIsomorphicLayoutEffect(function () {
         var update = function () {
             var newFixedOffset = calculateFixedOffset();
             fixedOffset.current = newFixedOffset;
-            // inject this CSS make the hashed deeplinks position the scroll at the
-            // right offset
             inject(newFixedOffset);
         };
         update();
         if (ResizeObserver) {
-            // const elements = $$("[data-fixed]");
             var observer_1 = new ResizeObserver(function (entries) {
                 var newFixedOffset = 0;
                 entries.forEach(function (entry) {

package/{hooks/useFocus.d.ts → useFocus.d.ts}

@@ -1,6 +1,3 @@
 /// <reference types="react" />
-/**
- * @see https://stackoverflow.com/a/54159564/1938970
- */
 export declare const useFocus: () => (import("react").RefObject<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement> | (() => void))[];
 export default useFocus;

package/{hooks/useFocus.mjs → useFocus.js}

@@ -1,7 +1,4 @@
 import { useRef } from "react";
-/**
- * @see https://stackoverflow.com/a/54159564/1938970
- */
 export var useFocus = function () {
     var elementRef = useRef(null);
     var setFocus = function () {

package/useInterval.d.ts

@@ -0,0 +1,2 @@
+export declare function useInterval<T extends () => unknown>(callback: T, delay: number, deps?: unknown[]): void;
+export default useInterval;

package/{hooks/useInterval.mjs → useInterval.js}

@@ -1,18 +1,12 @@
-import { __spreadArray } from "tslib";
+import { __read, __spreadArray } from "tslib";
 import { useEffect, useRef } from "react";
-import noop from "@koine/utils/noop";
-/**
- * @borrows [dan abramov](https://overreacted.io/making-setinterval-declarative-with-react-hooks/)
- *
- * We just add `deps` array argument and typescript support
- */
+import { noop } from "@koine/utils";
 export function useInterval(callback, delay, deps) {
     if (deps === void 0) { deps = []; }
     var savedCallback = useRef();
     useEffect(function () {
         savedCallback.current = callback;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, __spreadArray([callback], deps, true));
+    }, __spreadArray([callback], __read(deps), false));
     useEffect(function () {
         function tick() {
             if (savedCallback.current)

package/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+export default useIsomorphicLayoutEffect;

package/{hooks/useIsomorphicLayoutEffect.mjs → useIsomorphicLayoutEffect.js}

@@ -1,8 +1,5 @@
 import { useEffect, useLayoutEffect } from "react";
-import isBrowser from "@koine/utils/isBrowser";
-/**
- * @borrows [streamich/react-use](https://github.com/streamich/react-use/blob/master/src/useIsomorphicLayoutEffect.ts)
- */
+import { isBrowser } from "@koine/utils";
 export var useIsomorphicLayoutEffect = isBrowser
     ? useLayoutEffect
     : useEffect;

package/{hooks/useKeyUp.mjs → useKeyUp.js}

@@ -1,14 +1,10 @@
-import { __spreadArray } from "tslib";
+import { __read, __spreadArray } from "tslib";
 import { useEffect } from "react";
-import on from "@koine/dom/on";
+import { on } from "@koine/dom";
 export function useKeyUp(callback, deps) {
     if (deps === void 0) { deps = []; }
     useEffect(function () {
         var listener = on(window, "keyup", function (event) {
-            // const { key } = event;
-            // be sure we do not intercept keys combinations maybe used for other
-            // actions like native browser navigation shortcuts
-            // @see https://stackoverflow.com/a/37559790/1938970
             if (!event.ctrlKey &&
                 !event.altKey &&
                 !event.shiftKey &&
@@ -17,7 +13,6 @@ export function useKeyUp(callback, deps) {
             }
         });
         return listener;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, __spreadArray([callback], deps, true));
+    }, __spreadArray([callback], __read(deps), false));
 }
 export default useKeyUp;

package/{hooks/useMeasure.d.ts → useMeasure.d.ts}

@@ -18,10 +18,5 @@ export type UseMeasureReturn = [
     RectReadOnly,
     () => void
 ];
-/**
- * Use measure hook
- *
- * @borrows [pmndrs/react-use-measure](https://github.com/pmndrs/react-use-measure)
- */
 export declare function useMeasure(options?: UseMeasureOptions): UseMeasureReturn;
 export default useMeasure;

package/{hooks/useMeasure.mjs → useMeasure.js}

@@ -1,13 +1,8 @@
-import { __spreadArray } from "tslib";
-import { useEffect, useState, useRef, useMemo } from "react";
-import debounce from "@koine/utils/debounce";
-import noop from "@koine/utils/noop";
-import listenResizeDebounced from "@koine/dom/listenResizeDebounced";
-import listenScrollDebounced from "@koine/dom/listenScrollDebounced";
-import on from "@koine/dom/on";
-import off from "@koine/dom/off";
+import { __read, __spreadArray } from "tslib";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { debounce, noop } from "@koine/utils";
+import { listenResizeDebounced, listenScrollDebounced, off, on, } from "@koine/dom";
 var observer;
-// Returns a list of scroll offsets
 function findScrollContainers(element) {
     var result = [];
     if (!element || element === document.body)
@@ -15,7 +10,7 @@ function findScrollContainers(element) {
     var _a = window.getComputedStyle(element), overflow = _a.overflow, overflowX = _a.overflowX, overflowY = _a.overflowY;
     if ([overflow, overflowX, overflowY].some(function (prop) { return prop === "auto" || prop === "scroll"; }))
         result.push(element);
-    return __spreadArray(__spreadArray([], result, true), findScrollContainers(element.parentElement), true);
+    return __spreadArray(__spreadArray([], __read(result), false), __read(findScrollContainers(element.parentElement)), false);
 }
 var keys = [
     "x",
@@ -30,14 +25,9 @@ var keys = [
 var areBoundsEqual = function (a, b) {
     return keys.every(function (key) { return a[key] === b[key]; });
 };
-/**
- * Use measure hook
- *
- * @borrows [pmndrs/react-use-measure](https://github.com/pmndrs/react-use-measure)
- */
 export function useMeasure(options) {
-    var _a = (options || {}).scroll /* offsetSize = false */, scroll = _a === void 0 ? false : _a /* offsetSize = false */;
-    var _b = useState({
+    var _a = (options || {}).scroll, scroll = _a === void 0 ? false : _a;
+    var _b = __read(useState({
         left: 0,
         top: 0,
         width: 0,
@@ -46,39 +36,28 @@ export function useMeasure(options) {
         right: 0,
         x: 0,
         y: 0,
-    }), bounds = _b[0], setBounds = _b[1];
-    // keep all state in a ref
+    }), 2), bounds = _b[0], setBounds = _b[1];
     var state = useRef([
-        // element
         null,
-        // scrollContainers
         null,
-        // resizeObserver
         null,
-        // lastBounds
         bounds,
     ]);
-    // make sure to update state only as long as the component is truly mounted
     var mounted = useRef(false);
     useEffect(function () {
         mounted.current = true;
         return function () { return void (mounted.current = false); };
     }, []);
-    // memoize handlers, so event-listeners know when they should update
-    var _c = useMemo(function () {
+    var _c = __read(useMemo(function () {
         var callback = function () {
             var _args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 _args[_i] = arguments[_i];
             }
-            var _a = state.current, element = _a[0], lastBounds = _a[3];
+            var _a = __read(state.current, 4), element = _a[0], lastBounds = _a[3];
             if (!element)
                 return;
             var size = element.getBoundingClientRect();
-            // if (element instanceof HTMLElement && offsetSize) {
-            //   size.height = element.offsetHeight;
-            //   size.width = element.offsetWidth;
-            // }
             Object.freeze(size);
             if (mounted.current && !areBoundsEqual(lastBounds, size)) {
                 state.current[3] = size;
@@ -87,10 +66,9 @@ export function useMeasure(options) {
         };
         var debouncedCallback = debounce(callback);
         return [callback, debouncedCallback, debouncedCallback];
-    }, [setBounds /* , offsetSize */]), forceRefresh = _c[0] /* resizeChange */, scrollChange = _c[2];
-    // cleanup current scroll-listeners / observers
+    }, [setBounds]), 3), forceRefresh = _c[0], scrollChange = _c[2];
     function removeListeners() {
-        var _a = state.current, scrollContainers = _a[1], resizeObserver = _a[2];
+        var _a = __read(state.current, 3), scrollContainers = _a[1], resizeObserver = _a[2];
         if (scrollContainers) {
             scrollContainers.forEach(function (element) {
                 return off(element, "scroll", scrollChange);
@@ -102,9 +80,8 @@ export function useMeasure(options) {
             state.current[2] = null;
         }
     }
-    // add scroll-listeners / observers
     function addListeners() {
-        var _a = state.current, element = _a[0], scrollContainers = _a[1];
+        var _a = __read(state.current, 2), element = _a[0], scrollContainers = _a[1];
         if (!element)
             return;
         if (!observer && ResizeObserver) {
@@ -121,7 +98,6 @@ export function useMeasure(options) {
             }
         }
     }
-    // the ref we expose to the user
     var ref = function (node) {
         if (!node || node === state.current[0])
             return;
@@ -130,12 +106,6 @@ export function useMeasure(options) {
         state.current[1] = findScrollContainers(node);
         addListeners();
     };
-    // add general event listeners
-    // useOnWindowScroll(forceRefresh, Boolean(scroll));
-    // useOnWindowResize(() => {
-    //   debugger;
-    //   forceRefresh();
-    // });
     useEffect(function () {
         if (scroll) {
             var listener = listenScrollDebounced(0, forceRefresh, 100);
@@ -144,23 +114,16 @@ export function useMeasure(options) {
         return noop;
     }, [scroll, forceRefresh]);
     useEffect(function () {
-        // const listener = listenResizeDebounced(onWindowResize);
-        // return listener;
         var listener = listenResizeDebounced(0, forceRefresh, 100);
         return listener;
     }, [forceRefresh]);
-    // respond to changes that are relevant for the listeners
     useEffect(function () {
         removeListeners();
         addListeners();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [scroll /* , scrollChange, resizeChange */]);
+    }, [scroll]);
     useEffect(function () {
-        // operate on mount, @kuus on the original version there is no call on mount?
         forceRefresh();
-        // remove all listeners when the components unmounts
         return removeListeners;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
     return [ref, bounds, forceRefresh];
 }

package/useMountedState.d.ts

@@ -0,0 +1,2 @@
+export declare function useMountedState(): () => boolean;
+export default useMountedState;

package/{hooks/useMountedState.mjs → useMountedState.js}

@@ -1,7 +1,4 @@
 import { useCallback, useEffect, useRef } from "react";
-/**
- * @borrows [streamich/react-use](https://github.com/streamich/react-use/blob/master/src/useMountedState.ts)
- */
 export function useMountedState() {
     var mountedRef = useRef(false);
     var get = useCallback(function () { return mountedRef.current; }, []);

package/useNavigateAway.d.ts

@@ -0,0 +1,3 @@
+export type UseNavigateAwayHandler = (event: BeforeUnloadEvent) => string | boolean;
+export declare const useNavigateAway: (handler: UseNavigateAwayHandler) => void;
+export default useNavigateAway;

package/useNavigateAway.js

@@ -0,0 +1,25 @@
+import { useEffect, useRef } from "react";
+import { on } from "@koine/dom";
+export var useNavigateAway = function (handler) {
+    var beforeUnloadHandlerRef = useRef();
+    useEffect(function () {
+        beforeUnloadHandlerRef.current = function (event) {
+            var customMessageOrCondition = handler(event);
+            if (customMessageOrCondition) {
+                event.preventDefault();
+            }
+            if (typeof customMessageOrCondition === "string") {
+                return (event.returnValue = customMessageOrCondition);
+            }
+            if (event.defaultPrevented) {
+                return (event.returnValue = "");
+            }
+            return;
+        };
+    }, [handler]);
+    useEffect(function () {
+        var listenerBeforeunload = on(window, "beforeunload", function (event) { var _a; return (_a = beforeUnloadHandlerRef.current) === null || _a === void 0 ? void 0 : _a.call(beforeUnloadHandlerRef, event); });
+        return listenerBeforeunload;
+    }, []);
+};
+export default useNavigateAway;

package/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export declare function usePrevious<T>(state: T, defaulValue: T): T;
+export default usePrevious;

package/usePrevious.js

@@ -0,0 +1,10 @@
+import { __read } from "tslib";
+import { useState } from "react";
+export function usePrevious(state, defaulValue) {
+    var _a = __read(useState([state, defaulValue]), 2), tuple = _a[0], setTuple = _a[1];
+    if (tuple[1] !== state) {
+        setTuple([tuple[1], state]);
+    }
+    return tuple[0];
+}
+export default usePrevious;

package/{hooks/useScrollPosition.d.ts → useScrollPosition.d.ts}

@@ -4,12 +4,5 @@ type Position = {
     y: number;
 };
 type ElementRef = React.MutableRefObject<HTMLElement | undefined>;
-/**
- * @borrows [@n8tb1t/use-scroll-position@2.0.3](https://github.com/n8tb1t/use-scroll-position) by `n8tb1t <n8tb1t@gmail.com>`
- *
- * We've just:
- * - reused internal helper functions
- * - compacted object arguments in functions as plain argument list to improve compression
- */
 export declare const useScrollPosition: (effect: (currentPosition: Position, prevPosition: Position) => void, deps?: import("react").DependencyList, element?: ElementRef, boundingElement?: ElementRef, wait?: number) => void;
 export default useScrollPosition;

package/{hooks/useScrollPosition.mjs → useScrollPosition.js}

@@ -1,7 +1,7 @@
 import { useRef } from "react";
-import isBrowser from "@koine/utils/isBrowser";
-import listenScroll from "@koine/dom/listenScroll";
-import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect";
+import { isBrowser } from "@koine/utils";
+import { listenScroll } from "@koine/dom";
+import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect.js";
 var zeroPosition = { x: 0, y: 0 };
 var getClientRect = function (element) {
     return element === null || element === void 0 ? void 0 : element.getBoundingClientRect();
@@ -25,13 +25,6 @@ var getScrollPosition = function (element, boundingElement) {
         }
         : { x: targetPosition.left, y: targetPosition.top };
 };
-/**
- * @borrows [@n8tb1t/use-scroll-position@2.0.3](https://github.com/n8tb1t/use-scroll-position) by `n8tb1t <n8tb1t@gmail.com>`
- *
- * We've just:
- * - reused internal helper functions
- * - compacted object arguments in functions as plain argument list to improve compression
- */
 export var useScrollPosition = function (effect, deps, element, boundingElement, wait) {
     if (deps === void 0) { deps = []; }
     var position = useRef(getScrollPosition(null, boundingElement));

package/{hooks/useScrollThreshold.mjs → useScrollThreshold.js}

@@ -1,14 +1,14 @@
+import { __read } from "tslib";
 import { useCallback, useEffect, useState } from "react";
-import noop from "@koine/utils/noop";
-import listenScroll from "@koine/dom/listenScroll";
+import { noop } from "@koine/utils";
+import { listenScroll } from "@koine/dom";
 export var useScrollThreshold = function (threshold, callback) {
-    var _a = useState(false), isBelow = _a[0], setIsBelow = _a[1];
+    var _a = __read(useState(false), 2), isBelow = _a[0], setIsBelow = _a[1];
     var handler = useCallback(function () {
         if (threshold) {
-            var posY = window.scrollY; // * -1;
+            var posY = window.scrollY;
             var isAbove = posY < threshold;
             var isBelow_1 = posY > threshold;
-            // console.log("useScrollThreshold setIsBelow", isBelow, posY, threshold);
             setIsBelow(isBelow_1);
             if (callback)
                 callback(isAbove, isBelow_1);
@@ -16,7 +16,6 @@ export var useScrollThreshold = function (threshold, callback) {
     }, [threshold, callback]);
     useEffect(function () {
         if (threshold) {
-            // const listener = listenScrollThrottled(0, handler, 50);
             var listener = listenScroll(handler);
             handler();
             return listener;

package/{hooks/useScrollTo.mjs → useScrollTo.js}

@@ -1,9 +1,10 @@
-import isBrowser from "@koine/utils/isBrowser";
-import useHeader from "../Header/useHeader";
+import { __read } from "tslib";
+import { isBrowser } from "@koine/utils";
+import useHeader from "./Header/useHeader.js";
 export function useScrollTo(id, offset) {
     if (id === void 0) { id = ""; }
     if (offset === void 0) { offset = 0; }
-    var _a = useHeader(), headerHeight = _a[2];
+    var _a = __read(useHeader(), 3), headerHeight = _a[2];
     if (!isBrowser) {
         return;
     }

package/{hooks/useSmoothScroll.d.ts → useSmoothScroll.d.ts}

@@ -1,8 +1,2 @@
-/**
- *
- * @param disregardAutomaticFixedOffset When the `to` scroll argument is a DOM
- * selector we will keep into account the _fixedOffset_ despite this option.
- * @returns
- */
 export declare function useSmoothScroll(disregardAutomaticFixedOffset?: boolean): (to?: number | string, customOffset?: number, callback?: () => void, fallbackTimeout?: number, behavior?: ScrollBehavior) => void;
 export default useSmoothScroll;

package/{hooks/useSmoothScroll.mjs → useSmoothScroll.js}

@@ -1,14 +1,7 @@
 import { useCallback } from "react";
-import isNumber from "@koine/utils/isNumber";
-import getOffsetTopSlim from "@koine/dom/getOffsetTopSlim";
-import scrollTo from "@koine/dom/scrollTo";
-import useFixedOffset from "./useFixedOffset";
-/**
- *
- * @param disregardAutomaticFixedOffset When the `to` scroll argument is a DOM
- * selector we will keep into account the _fixedOffset_ despite this option.
- * @returns
- */
+import { isNumber } from "@koine/utils";
+import { getOffsetTopSlim, scrollTo } from "@koine/dom";
+import useFixedOffset from "./useFixedOffset.js";
 export function useSmoothScroll(disregardAutomaticFixedOffset) {
     var fixedOffset = useFixedOffset();
     var scroll = useCallback(function (to, customOffset, callback, fallbackTimeout, behavior) {

package/useSpinDelay.d.ts

@@ -0,0 +1,2 @@
+export declare function useSpinDelay(loading: boolean, delay?: number, minDuration?: number): boolean;
+export default useSpinDelay;

package/{hooks/useSpinDelay.mjs → useSpinDelay.js}

@@ -1,4 +1,5 @@
-import { useEffect, useState, useRef } from "react";
+import { __read } from "tslib";
+import { useEffect, useRef, useState } from "react";
 var State;
 (function (State) {
     State[State["IDLE"] = 0] = "IDLE";
@@ -6,22 +7,10 @@ var State;
     State[State["DISPLAY"] = 2] = "DISPLAY";
     State[State["EXPIRE"] = 3] = "EXPIRE";
 })(State || (State = {}));
-/**
- * Wraps your booleans only returning true after the `delay`, and for a minimum
- * time of `minDuration`. This way you're sure that you don't show unnecessary
- * or very short living spinners.
- *
- * @borrows [smeijer/spin-delay](https://github.com/smeijer/spin-delay)
- *
- * - Smaller footprint and options object as argument
- *
- * @param delay [500]
- * @param minDuration [200]
- */
 export function useSpinDelay(loading, delay, minDuration) {
     if (delay === void 0) { delay = 500; }
     if (minDuration === void 0) { minDuration = 200; }
-    var _a = useState(State.IDLE), state = _a[0], setState = _a[1];
+    var _a = __read(useState(State.IDLE), 2), state = _a[0], setState = _a[1];
     var timeout = useRef();
     useEffect(function () {
         if (loading && state === State.IDLE) {

package/{hooks/useTraceUpdate.d.ts → useTraceUpdate.d.ts}

@@ -1,5 +1,2 @@
-/**
- * @see https://stackoverflow.com/a/51082563/9122820
- */
 export declare function useTraceUpdate(props: any): void;
 export default useTraceUpdate;

package/{hooks/useTraceUpdate.mjs → useTraceUpdate.js}

@@ -1,14 +1,11 @@
+import { __read } from "tslib";
 import { useEffect, useRef } from "react";
-/**
- * @see https://stackoverflow.com/a/51082563/9122820
- */
 export function useTraceUpdate(props) {
     var prev = useRef(props);
     useEffect(function () {
         var changedProps = Object.entries(props).reduce(function (ps, _a) {
-            var k = _a[0], v = _a[1];
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
             if (prev.current[k] !== v) {
-                // @ts-expect-error Does not matter here...
                 ps[k] = [prev.current[k], v];
             }
             return ps;

package/{hooks/useUpdateEffect.d.ts → useUpdateEffect.d.ts}

@@ -1,6 +1,3 @@
 import { useEffect } from "react";
-/**
- * @borrows [streamich/react-use](https://github.com/streamich/react-use/blob/master/src/useUpdateEffect.ts)
- */
 export declare const useUpdateEffect: typeof useEffect;
 export default useUpdateEffect;

package/{hooks/useUpdateEffect.mjs → useUpdateEffect.js}

@@ -1,15 +1,11 @@
 import { useEffect } from "react";
-import { useFirstMountState } from "./useFirstMountState";
-/**
- * @borrows [streamich/react-use](https://github.com/streamich/react-use/blob/master/src/useUpdateEffect.ts)
- */
+import { useFirstMountState } from "./useFirstMountState.js";
 export var useUpdateEffect = function (effect, deps) {
     var isFirstMount = useFirstMountState();
     useEffect(function () {
         if (!isFirstMount) {
             return effect();
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, deps);
 };
 export default useUpdateEffect;

package/useWindowSize.d.ts

@@ -0,0 +1,3 @@
+import { debounce } from "@koine/utils";
+export declare function useWindowSize(wait?: Parameters<typeof debounce>[1], immediate?: Parameters<typeof debounce>[2]): readonly [number, number];
+export default useWindowSize;