meticulous-ui 3.7.11 → 3.7.13

package/hooks/index.js

@@ -1,38 +1,38 @@
-import { default as default2 } from "./usePrevious.js";
-import { default as default3 } from "./useDebounce.js";
-import { default as default4 } from "./useThrottle.js";
-import { default as default5 } from "./useIsMounted.js";
-import { default as default6 } from "./useEventListener.js";
-import { default as default7 } from "./useIntersectionObserver.js";
-import { default as default8 } from "./useMediaQuery.js";
-import { default as default9 } from "./useLocalStorage.js";
-import { default as default10 } from "./useSessionStorage.js";
-import { default as default11 } from "./useOutsideClick.js";
-import { default as default12 } from "./useWindowSize.js";
-import { default as default13 } from "./useOnlineStatus.js";
-import { default as default14 } from "./useCopyToClipboard.js";
-import { default as default15 } from "./useToggle.js";
-import { default as default16 } from "./useTimeout.js";
-import { default as default17 } from "./useInterval.js";
-import { default as default18 } from "./useUnmount.js";
-import { default as default19 } from "./useFirstRender.js";
+import { default as t } from "./usePrevious.js";
+import { default as s } from "./useDebounce.js";
+import { default as a } from "./useThrottle.js";
+import { default as l } from "./useIsMounted.js";
+import { default as m } from "./useEventListener.js";
+import { default as x } from "./useIntersectionObserver.js";
+import { default as i } from "./useMediaQuery.js";
+import { default as c } from "./useLocalStorage.js";
+import { default as v } from "./useSessionStorage.js";
+import { default as b } from "./useOutsideClick.js";
+import { default as I } from "./useWindowSize.js";
+import { default as y } from "./useOnlineStatus.js";
+import { default as M } from "./useCopyToClipboard.js";
+import { default as k } from "./useToggle.js";
+import { default as z } from "./useTimeout.js";
+import { default as E } from "./useInterval.js";
+import { default as P } from "./useUnmount.js";
+import { default as R } from "./useFirstRender.js";
 export {
-  default14 as useCopyToClipboard,
-  default3 as useDebounce,
-  default6 as useEventListener,
-  default19 as useFirstRender,
-  default7 as useIntersectionObserver,
-  default17 as useInterval,
-  default5 as useIsMounted,
-  default9 as useLocalStorage,
-  default8 as useMediaQuery,
-  default13 as useOnlineStatus,
-  default11 as useOutsideClick,
-  default2 as usePrevious,
-  default10 as useSessionStorage,
-  default4 as useThrottle,
-  default16 as useTimeout,
-  default15 as useToggle,
-  default18 as useUnmount,
-  default12 as useWindowSize
+  M as useCopyToClipboard,
+  s as useDebounce,
+  m as useEventListener,
+  R as useFirstRender,
+  x as useIntersectionObserver,
+  E as useInterval,
+  l as useIsMounted,
+  c as useLocalStorage,
+  i as useMediaQuery,
+  y as useOnlineStatus,
+  b as useOutsideClick,
+  t as usePrevious,
+  v as useSessionStorage,
+  a as useThrottle,
+  z as useTimeout,
+  k as useToggle,
+  P as useUnmount,
+  I as useWindowSize
 };

package/hooks/useCopyToClipboard.js

@@ -1,17 +1,14 @@
-import { useState } from "react";
-const useCopyToClipboard = () => {
-  const [copied, setCopied] = useState(false);
-  const copy = async (text) => {
+import { useState as a } from "react";
+const i = () => {
+  const [e, t] = a(!1);
+  return [e, async (o) => {
     try {
-      await navigator.clipboard.writeText(text);
-      setCopied(true);
-      setTimeout(() => setCopied(false), 2e3);
-    } catch (e) {
-      setCopied(false);
+      await navigator.clipboard.writeText(o), t(!0), setTimeout(() => t(!1), 2e3);
+    } catch (r) {
+      t(!1);
     }
-  };
-  return [copied, copy];
+  }];
 };
 export {
-  useCopyToClipboard as default
+  i as default
 };

package/hooks/useDebounce.js

@@ -1,12 +1,11 @@
-import { useState, useEffect } from "react";
-const useDebounce = (value, delay) => {
-  const [debounced, setDebounced] = useState(value);
-  useEffect(() => {
-    const id = setTimeout(() => setDebounced(value), delay);
-    return () => clearTimeout(id);
-  }, [value, delay]);
-  return debounced;
+import { useState as c, useEffect as n } from "react";
+const d = (e, t) => {
+  const [o, s] = c(e);
+  return n(() => {
+    const u = setTimeout(() => s(e), t);
+    return () => clearTimeout(u);
+  }, [e, t]), o;
 };
 export {
-  useDebounce as default
+  d as default
 };

package/hooks/useEventListener.js

@@ -1,17 +1,15 @@
-import { useRef, useEffect } from "react";
-const useEventListener = (event, handler, target = window) => {
-  const savedHandler = useRef(handler);
-  useEffect(() => {
-    savedHandler.current = handler;
-  }, [handler]);
-  useEffect(() => {
-    const el = target && "current" in target ? target.current : target;
-    if (!(el == null ? void 0 : el.addEventListener)) return;
-    const listener = (e) => savedHandler.current(e);
-    el.addEventListener(event, listener);
-    return () => el.removeEventListener(event, listener);
-  }, [event, target]);
+import { useRef as o, useEffect as c } from "react";
+const f = (r, s, e = window) => {
+  const t = o(s);
+  c(() => {
+    t.current = s;
+  }, [s]), c(() => {
+    const n = e && "current" in e ? e.current : e;
+    if (!(n != null && n.addEventListener)) return;
+    const u = (i) => t.current(i);
+    return n.addEventListener(r, u), () => n.removeEventListener(r, u);
+  }, [r, e]);
 };
 export {
-  useEventListener as default
+  f as default
 };

package/hooks/useFirstRender.js

@@ -1,11 +1,10 @@
-import { useRef, useEffect } from "react";
-const useFirstRender = () => {
-  const isFirst = useRef(true);
-  useEffect(() => {
-    isFirst.current = false;
-  }, []);
-  return isFirst.current;
+import { useRef as r, useEffect as t } from "react";
+const u = () => {
+  const e = r(!0);
+  return t(() => {
+    e.current = !1;
+  }, []), e.current;
 };
 export {
-  useFirstRender as default
+  u as default
 };

package/hooks/useIntersectionObserver.js

@@ -1,15 +1,13 @@
-import { useState, useEffect } from "react";
-const useIntersectionObserver = (ref, options = {}) => {
-  const [entry, setEntry] = useState(null);
-  useEffect(() => {
-    const el = ref.current;
-    if (!el) return;
-    const observer = new IntersectionObserver(([e]) => setEntry(e), options);
-    observer.observe(el);
-    return () => observer.disconnect();
-  }, [ref, options.threshold, options.root, options.rootMargin]);
-  return entry;
+import { useState as u, useEffect as l } from "react";
+const b = (r, e = {}) => {
+  const [s, o] = u(null);
+  return l(() => {
+    const t = r.current;
+    if (!t) return;
+    const n = new IntersectionObserver(([c]) => o(c), e);
+    return n.observe(t), () => n.disconnect();
+  }, [r, e.threshold, e.root, e.rootMargin]), s;
 };
 export {
-  useIntersectionObserver as default
+  b as default
 };

package/hooks/useInterval.js

@@ -1,15 +1,14 @@
-import { useRef, useEffect } from "react";
-const useInterval = (callback, delay) => {
-  const savedCallback = useRef(callback);
-  useEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    if (delay === null) return;
-    const id = setInterval(() => savedCallback.current(), delay);
-    return () => clearInterval(id);
-  }, [delay]);
+import { useRef as u, useEffect as n } from "react";
+const o = (e, r) => {
+  const t = u(e);
+  n(() => {
+    t.current = e;
+  }, [e]), n(() => {
+    if (r === null) return;
+    const s = setInterval(() => t.current(), r);
+    return () => clearInterval(s);
+  }, [r]);
 };
 export {
-  useInterval as default
+  o as default
 };

package/hooks/useIsMounted.js

@@ -1,14 +1,10 @@
-import { useRef, useEffect } from "react";
-const useIsMounted = () => {
-  const isMounted = useRef(false);
-  useEffect(() => {
-    isMounted.current = true;
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  return isMounted;
+import { useRef as t, useEffect as r } from "react";
+const s = () => {
+  const e = t(!1);
+  return r(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
 };
 export {
-  useIsMounted as default
+  s as default
 };

package/hooks/useLocalStorage.js

@@ -1,30 +1,28 @@
-import { useState } from "react";
-const useLocalStorage = (key, initialValue) => {
-  const [stored, setStored] = useState(() => {
+import { useState as n } from "react";
+const l = (e, o) => {
+  const [r, c] = n(() => {
     try {
-      const item = localStorage.getItem(key);
-      return item !== null ? JSON.parse(item) : initialValue;
-    } catch (e) {
-      return initialValue;
+      const t = localStorage.getItem(e);
+      return t !== null ? JSON.parse(t) : o;
+    } catch (t) {
+      return o;
     }
   });
-  const setValue = (value) => {
-    const next = typeof value === "function" ? value(stored) : value;
-    setStored(next);
+  return [r, (t) => {
+    const s = typeof t == "function" ? t(r) : t;
+    c(s);
     try {
-      localStorage.setItem(key, JSON.stringify(next));
-    } catch (e) {
+      localStorage.setItem(e, JSON.stringify(s));
+    } catch (S) {
     }
-  };
-  const remove = () => {
-    setStored(initialValue);
+  }, () => {
+    c(o);
     try {
-      localStorage.removeItem(key);
-    } catch (e) {
+      localStorage.removeItem(e);
+    } catch (t) {
     }
-  };
-  return [stored, setValue, remove];
+  }];
 };
 export {
-  useLocalStorage as default
+  l as default
 };

package/hooks/useMediaQuery.js

@@ -1,14 +1,11 @@
-import { useState, useEffect } from "react";
-const useMediaQuery = (query) => {
-  const [matches, setMatches] = useState(() => window.matchMedia(query).matches);
-  useEffect(() => {
-    const mql = window.matchMedia(query);
-    const handler = (e) => setMatches(e.matches);
-    mql.addEventListener("change", handler);
-    return () => mql.removeEventListener("change", handler);
-  }, [query]);
-  return matches;
+import { useState as o, useEffect as r } from "react";
+const h = (e) => {
+  const [n, s] = o(() => window.matchMedia(e).matches);
+  return r(() => {
+    const t = window.matchMedia(e), a = (c) => s(c.matches);
+    return t.addEventListener("change", a), () => t.removeEventListener("change", a);
+  }, [e]), n;
 };
 export {
-  useMediaQuery as default
+  h as default
 };

package/hooks/useOnlineStatus.js

@@ -1,18 +1,13 @@
-import { useState, useEffect } from "react";
-const useOnlineStatus = () => {
-  const [isOnline, setIsOnline] = useState(navigator.onLine);
-  useEffect(() => {
-    const onOnline = () => setIsOnline(true);
-    const onOffline = () => setIsOnline(false);
-    window.addEventListener("online", onOnline);
-    window.addEventListener("offline", onOffline);
-    return () => {
-      window.removeEventListener("online", onOnline);
-      window.removeEventListener("offline", onOffline);
+import { useState as o, useEffect as s } from "react";
+const f = () => {
+  const [i, e] = o(navigator.onLine);
+  return s(() => {
+    const n = () => e(!0), t = () => e(!1);
+    return window.addEventListener("online", n), window.addEventListener("offline", t), () => {
+      window.removeEventListener("online", n), window.removeEventListener("offline", t);
     };
-  }, []);
-  return isOnline;
+  }, []), i;
 };
 export {
-  useOnlineStatus as default
+  f as default
 };

package/hooks/useOutsideClick.js

@@ -1,17 +1,14 @@
-import { useEffect } from "react";
-const useOutsideClick = (ref, callback) => {
-  useEffect(() => {
-    const handler = (e) => {
-      if (ref.current && !ref.current.contains(e.target)) callback(e);
+import { useEffect as r } from "react";
+const u = (e, n) => {
+  r(() => {
+    const t = (o) => {
+      e.current && !e.current.contains(o.target) && n(o);
     };
-    document.addEventListener("mousedown", handler);
-    document.addEventListener("touchstart", handler);
-    return () => {
-      document.removeEventListener("mousedown", handler);
-      document.removeEventListener("touchstart", handler);
+    return document.addEventListener("mousedown", t), document.addEventListener("touchstart", t), () => {
+      document.removeEventListener("mousedown", t), document.removeEventListener("touchstart", t);
     };
-  }, [ref, callback]);
+  }, [e, n]);
 };
 export {
-  useOutsideClick as default
+  u as default
 };

package/hooks/usePrevious.js

@@ -1,11 +1,10 @@
-import { useRef, useEffect } from "react";
-const usePrevious = (value) => {
-  const ref = useRef(void 0);
-  useEffect(() => {
-    ref.current = value;
-  });
-  return ref.current;
+import { useRef as t, useEffect as u } from "react";
+const n = (r) => {
+  const e = t(void 0);
+  return u(() => {
+    e.current = r;
+  }), e.current;
 };
 export {
-  usePrevious as default
+  n as default
 };

package/hooks/useSessionStorage.js

@@ -1,30 +1,28 @@
-import { useState } from "react";
-const useSessionStorage = (key, initialValue) => {
-  const [stored, setStored] = useState(() => {
+import { useState as c } from "react";
+const u = (e, s) => {
+  const [o, r] = c(() => {
     try {
-      const item = sessionStorage.getItem(key);
-      return item !== null ? JSON.parse(item) : initialValue;
-    } catch (e) {
-      return initialValue;
+      const t = sessionStorage.getItem(e);
+      return t !== null ? JSON.parse(t) : s;
+    } catch (t) {
+      return s;
     }
   });
-  const setValue = (value) => {
-    const next = typeof value === "function" ? value(stored) : value;
-    setStored(next);
+  return [o, (t) => {
+    const n = typeof t == "function" ? t(o) : t;
+    r(n);
     try {
-      sessionStorage.setItem(key, JSON.stringify(next));
-    } catch (e) {
+      sessionStorage.setItem(e, JSON.stringify(n));
+    } catch (a) {
     }
-  };
-  const remove = () => {
-    setStored(initialValue);
+  }, () => {
+    r(s);
     try {
-      sessionStorage.removeItem(key);
-    } catch (e) {
+      sessionStorage.removeItem(e);
+    } catch (t) {
     }
-  };
-  return [stored, setValue, remove];
+  }];
 };
 export {
-  useSessionStorage as default
+  u as default
 };

package/hooks/useThrottle.js

@@ -1,17 +1,16 @@
-import { useState, useRef, useEffect } from "react";
-const useThrottle = (value, delay) => {
-  const [throttled, setThrottled] = useState(value);
-  const lastRan = useRef(Date.now());
-  useEffect(() => {
-    const remaining = delay - (Date.now() - lastRan.current);
-    const id = setTimeout(() => {
-      setThrottled(value);
-      lastRan.current = Date.now();
-    }, Math.max(0, remaining));
-    return () => clearTimeout(id);
-  }, [value, delay]);
-  return throttled;
+import { useState as c, useRef as u, useEffect as i } from "react";
+const f = (t, e) => {
+  const [r, n] = c(t), o = u(Date.now());
+  return i(() => {
+    const s = e - (Date.now() - o.current), a = setTimeout(
+      () => {
+        n(t), o.current = Date.now();
+      },
+      Math.max(0, s)
+    );
+    return () => clearTimeout(a);
+  }, [t, e]), r;
 };
 export {
-  useThrottle as default
+  f as default
 };

package/hooks/useTimeout.js

@@ -1,15 +1,14 @@
-import { useRef, useEffect } from "react";
-const useTimeout = (callback, delay) => {
-  const savedCallback = useRef(callback);
-  useEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    if (delay === null) return;
-    const id = setTimeout(() => savedCallback.current(), delay);
-    return () => clearTimeout(id);
-  }, [delay]);
+import { useRef as s, useEffect as u } from "react";
+const f = (e, t) => {
+  const r = s(e);
+  u(() => {
+    r.current = e;
+  }, [e]), u(() => {
+    if (t === null) return;
+    const o = setTimeout(() => r.current(), t);
+    return () => clearTimeout(o);
+  }, [t]);
 };
 export {
-  useTimeout as default
+  f as default
 };

package/hooks/useToggle.js

@@ -1,11 +1,10 @@
-import { useState, useCallback } from "react";
-const useToggle = (initial = false) => {
-  const [value, setValue] = useState(initial);
-  const toggle = useCallback((next) => {
-    setValue((v) => typeof next === "boolean" ? next : !v);
+import { useState as u, useCallback as r } from "react";
+const f = (o = !1) => {
+  const [t, a] = u(o), l = r((e) => {
+    a((s) => typeof e == "boolean" ? e : !s);
   }, []);
-  return [value, toggle];
+  return [t, l];
 };
 export {
-  useToggle as default
+  f as default
 };

package/hooks/useUnmount.js

@@ -1,13 +1,10 @@
-import { useRef, useEffect } from "react";
-const useUnmount = (callback) => {
-  const savedCallback = useRef(callback);
-  useEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    return () => savedCallback.current();
-  }, []);
+import { useRef as u, useEffect as r } from "react";
+const s = (e) => {
+  const t = u(e);
+  r(() => {
+    t.current = e;
+  }, [e]), r(() => () => t.current(), []);
 };
 export {
-  useUnmount as default
+  s as default
 };

package/hooks/useWindowSize.js

@@ -1,19 +1,14 @@
-import { useState, useEffect } from "react";
-const useWindowSize = () => {
-  const [size, setSize] = useState({
+import { useState as t, useEffect as r } from "react";
+const w = () => {
+  const [i, n] = t({
     width: window.innerWidth,
     height: window.innerHeight
   });
-  useEffect(() => {
-    const handler = () => setSize({
-      width: window.innerWidth,
-      height: window.innerHeight
-    });
-    window.addEventListener("resize", handler);
-    return () => window.removeEventListener("resize", handler);
-  }, []);
-  return size;
+  return r(() => {
+    const e = () => n({ width: window.innerWidth, height: window.innerHeight });
+    return window.addEventListener("resize", e), () => window.removeEventListener("resize", e);
+  }, []), i;
 };
 export {
-  useWindowSize as default
+  w as default
 };