@mwakidenis/logx-react 0.0.0-stage → 0.1.0

package/dist/hooks/index.mjs

@@ -0,0 +1,615 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { debounce, throttle } from '@mwakidenis/logx/function';
+import { localStorageHelpers, sessionStorageHelpers } from '@mwakidenis/logx/browser';
+import '@mwakidenis/logx/validation';
+import { pick, omit, merge, get, keys, values, entries, clone, deepClone, mapValues } from '@mwakidenis/logx/object';
+import '@mwakidenis/logx/number';
+import { unique, compact, shuffle, first, last, take, drop, flatten, partition, union, intersection, difference } from '@mwakidenis/logx/array';
+import '@mwakidenis/logx/async';
+import '@mwakidenis/logx/date';
+import '@mwakidenis/logx/string';
+
+// src/hooks/useToggle.ts
+function useToggle(initialValue = false) {
+  const [value, setValue] = useState(!!initialValue);
+  const toggle = useCallback(() => setValue((current) => !current), []);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  const set2 = useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { toggle, set: set2, setTrue, setFalse }];
+}
+function useBoolean(initialValue = false) {
+  const [value, setValue] = useState(!!initialValue);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  const toggle = useCallback(() => setValue((current) => !current), []);
+  const set2 = useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { setTrue, setFalse, toggle, set: set2 }];
+}
+function useCounter(initialValue = 0) {
+  const [count, setCount] = useState(initialValue);
+  const increment = useCallback(
+    (step = 1) => setCount((current) => current + step),
+    []
+  );
+  const decrement = useCallback(
+    (step = 1) => setCount((current) => current - step),
+    []
+  );
+  const reset = useCallback(() => setCount(initialValue), [initialValue]);
+  const set2 = useCallback((value) => setCount(value), []);
+  return { count, increment, decrement, reset, set: set2 };
+}
+function usePrevious(value) {
+  const ref = useRef(void 0);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+function useMounted() {
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => {
+    setMounted(true);
+    return () => setMounted(false);
+  }, []);
+  return mounted;
+}
+
+// src/hooks/useArray.ts
+function useArray(initialValue = []) {
+  const [array, setArray] = useState(initialValue);
+  const set2 = useCallback(
+    (value) => setArray(
+      (prev) => typeof value === "function" ? value(prev) : value
+    ),
+    []
+  );
+  const push = useCallback((...items) => setArray((prev) => [...prev, ...items]), []);
+  const unshift = useCallback((...items) => setArray((prev) => [...items, ...prev]), []);
+  const remove = useCallback(
+    (index) => setArray((prev) => prev.filter((_, i) => i !== index)),
+    []
+  );
+  const removeBy = useCallback(
+    (predicate) => setArray((prev) => prev.filter((v, i) => !predicate(v, i))),
+    []
+  );
+  const update = useCallback(
+    (index, value) => setArray((prev) => prev.map((v, i) => i === index ? value : v)),
+    []
+  );
+  const clear = useCallback(() => setArray([]), []);
+  const reset = useCallback(() => setArray(initialValue), [initialValue]);
+  const unique2 = useCallback(() => setArray((prev) => unique(prev)), []);
+  const compact2 = useCallback(() => setArray((prev) => compact(prev)), []);
+  const shuffle2 = useCallback(() => setArray((prev) => shuffle(prev)), []);
+  const firstValue = useCallback(() => first(array), [array]);
+  const lastValue = useCallback(() => last(array), [array]);
+  const takeValue = useCallback(
+    (count) => take(array, count),
+    [array]
+  );
+  const dropValue = useCallback(
+    (count) => drop(array, count),
+    [array]
+  );
+  return {
+    array,
+    set: set2,
+    push,
+    unshift,
+    remove,
+    removeBy,
+    update,
+    clear,
+    reset,
+    unique: unique2,
+    compact: compact2,
+    shuffle: shuffle2,
+    first: firstValue,
+    last: lastValue,
+    take: takeValue,
+    drop: dropValue,
+    // Expose LOGX-derived pure helpers for consumers who need them.
+    difference: useCallback(
+      (...others) => difference(array, ...others),
+      [array]
+    ),
+    intersection: useCallback(
+      (...others) => intersection(array, ...others),
+      [array]
+    ),
+    union: useCallback(
+      (...others) => union(array, ...others),
+      [array]
+    ),
+    partition: useCallback(
+      (predicate) => partition(array, predicate),
+      [array]
+    ),
+    flatten: useCallback(() => flatten(array), [array])
+  };
+}
+function useObject(initialValue = {}) {
+  const [object, setObject] = useState(initialValue);
+  const set2 = useCallback(
+    (value) => setObject(
+      (prev) => typeof value === "function" ? value(prev) : value
+    ),
+    []
+  );
+  const setKey = useCallback(
+    (key, value) => setObject((prev) => ({ ...prev, [key]: value })),
+    []
+  );
+  const removeKey = useCallback(
+    (key) => setObject((prev) => {
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    }),
+    []
+  );
+  const clear = useCallback(() => setObject({}), []);
+  const reset = useCallback(() => setObject(initialValue), [initialValue]);
+  const pickValue = useCallback(
+    (pickedKeys) => pick(object, pickedKeys),
+    [object]
+  );
+  const omitValue = useCallback(
+    (omittedKeys) => omit(object, omittedKeys),
+    [object]
+  );
+  const mergeValue = useCallback(
+    (sources) => merge(object, ...sources),
+    [object]
+  );
+  const getValue = useCallback(
+    (path) => get(object, path),
+    [object]
+  );
+  const keysValue = useCallback(() => keys(object), [object]);
+  const valuesValue = useCallback(() => values(object), [object]);
+  const entriesValue = useCallback(() => entries(object), [object]);
+  const cloneValue = useCallback(() => clone(object), [object]);
+  const deepCloneValue = useCallback(() => deepClone(object), [object]);
+  const mapValuesValue = useCallback(
+    (iteratee) => mapValues(object, iteratee),
+    [object]
+  );
+  return {
+    object,
+    set: set2,
+    setKey,
+    removeKey,
+    clear,
+    reset,
+    pick: pickValue,
+    omit: omitValue,
+    merge: mergeValue,
+    get: getValue,
+    keys: keysValue,
+    values: valuesValue,
+    entries: entriesValue,
+    clone: cloneValue,
+    deepClone: deepCloneValue,
+    mapValues: mapValuesValue
+  };
+}
+function useDebouncedValue(value, options = {}) {
+  const { delay = 300, leading = false } = options;
+  const [debounced, setDebounced] = useState(value);
+  const latest = useLatest(value);
+  const timerRef = useRef(null);
+  const lastLeadingRef = useRef(void 0);
+  useEffect(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    timerRef.current = setTimeout(() => {
+      setDebounced(latest.current);
+      timerRef.current = null;
+    }, delay);
+    return () => {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [value, delay]);
+  useEffect(() => {
+    if (!leading) return;
+    const current = latest.current;
+    if (lastLeadingRef.current !== current) {
+      lastLeadingRef.current = current;
+      setDebounced(current);
+    }
+  }, [value, leading]);
+  return debounced;
+}
+function useDebouncedCallback(callback, delay) {
+  const latest = useLatest(callback);
+  const debouncedRef = useRef(null);
+  useEffect(() => {
+    const debounced = debounce(
+      (...args) => {
+        latest.current(...args);
+      },
+      delay
+    );
+    debouncedRef.current = debounced;
+    return () => {
+      debounced.cancel();
+    };
+  }, [delay]);
+  const invoke = useCallback((...args) => {
+    debouncedRef.current?.(...args);
+  }, []);
+  const cancel = useCallback(() => {
+    debouncedRef.current?.cancel();
+  }, []);
+  const flush = useCallback(() => {
+    debouncedRef.current?.flush();
+  }, []);
+  const pending = useCallback(() => debouncedRef.current?.pending() ?? false, []);
+  return Object.assign(invoke, { cancel, flush, pending });
+}
+function useThrottle(callback, wait) {
+  const latest = useLatest(callback);
+  const throttledRef = useRef(null);
+  useEffect(() => {
+    const throttled = throttle(
+      (...args) => {
+        latest.current(...args);
+      },
+      wait
+    );
+    throttledRef.current = throttled;
+    return () => {
+      throttled.cancel();
+    };
+  }, [wait]);
+  const invoke = useCallback((...args) => {
+    throttledRef.current?.(...args);
+  }, []);
+  const cancel = useCallback(() => {
+    throttledRef.current?.cancel();
+  }, []);
+  const flush = useCallback(() => {
+    throttledRef.current?.flush();
+  }, []);
+  const pending = useCallback(() => throttledRef.current?.pending() ?? false, []);
+  return Object.assign(invoke, { cancel, flush, pending });
+}
+
+// src/internal/storage.ts
+var jsonSerializer = {
+  serialize: (value) => JSON.stringify(value),
+  deserialize: (raw) => {
+    if (raw === null) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/hooks/storage/useLocalStorage.ts
+function useLocalStorage(key, initialValue, options) {
+  const serializer = options?.serializer ?? jsonSerializer;
+  const [value, setValue] = useState(initialValue);
+  useEffect(() => {
+    const helpers = localStorageHelpers();
+    if (!helpers) return;
+    const raw = helpers.get(key);
+    if (raw === null) return;
+    const parsed = serializer.deserialize(raw);
+    if (parsed !== null) setValue(parsed);
+  }, [key, serializer]);
+  const set2 = useCallback(
+    (next) => setValue((prev) => {
+      const resolved = typeof next === "function" ? next(prev) : next;
+      const helpers = localStorageHelpers();
+      if (helpers) {
+        try {
+          helpers.set(key, serializer.serialize(resolved));
+        } catch {
+        }
+      }
+      return resolved;
+    }),
+    [key, serializer]
+  );
+  const remove = useCallback(() => {
+    setValue(initialValue);
+    const helpers = localStorageHelpers();
+    if (helpers) {
+      try {
+        helpers.remove(key);
+      } catch {
+      }
+    }
+  }, [key, initialValue]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handle = (event) => {
+      if (event.key === key && event.storageArea === localStorage) {
+        const parsed = event.newValue === null ? null : serializer.deserialize(event.newValue);
+        if (parsed !== null) setValue(parsed);
+      }
+    };
+    window.addEventListener("storage", handle);
+    return () => window.removeEventListener("storage", handle);
+  }, [key, serializer]);
+  return [value, set2, remove];
+}
+function useSessionStorage(key, initialValue, options) {
+  const serializer = options?.serializer ?? jsonSerializer;
+  const [value, setValue] = useState(initialValue);
+  useEffect(() => {
+    const helpers = sessionStorageHelpers();
+    if (!helpers) return;
+    const raw = helpers.get(key);
+    if (raw === null) return;
+    const parsed = serializer.deserialize(raw);
+    if (parsed !== null) setValue(parsed);
+  }, [key, serializer]);
+  const set2 = useCallback(
+    (next) => setValue((prev) => {
+      const resolved = typeof next === "function" ? next(prev) : next;
+      const helpers = sessionStorageHelpers();
+      if (helpers) {
+        try {
+          helpers.set(key, serializer.serialize(resolved));
+        } catch {
+        }
+      }
+      return resolved;
+    }),
+    [key, serializer]
+  );
+  const remove = useCallback(() => {
+    setValue(initialValue);
+    const helpers = sessionStorageHelpers();
+    if (helpers) {
+      try {
+        helpers.remove(key);
+      } catch {
+      }
+    }
+  }, [key, initialValue]);
+  return [value, set2, remove];
+}
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const media = window.matchMedia(query);
+    setMatches(media.matches);
+    const handler = (event) => setMatches(event.matches);
+    media.addEventListener("change", handler);
+    return () => {
+      media.removeEventListener("change", handler);
+    };
+  }, [query]);
+  return matches;
+}
+function useWindowSize() {
+  const [size, setSize] = useState(
+    () => typeof window !== "undefined" ? { width: window.innerWidth, height: window.innerHeight } : { width: 0, height: 0 }
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handler = () => setSize({ width: window.innerWidth, height: window.innerHeight });
+    window.addEventListener("resize", handler);
+    return () => window.removeEventListener("resize", handler);
+  }, []);
+  return size;
+}
+function useClickOutside(ref, handler) {
+  const latest = useRef(handler);
+  latest.current = handler;
+  useEffect(() => {
+    const handle = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        latest.current(event);
+      }
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("mousedown", handle);
+      document.addEventListener("touchstart", handle);
+      return () => {
+        document.removeEventListener("mousedown", handle);
+        document.removeEventListener("touchstart", handle);
+      };
+    }
+    return void 0;
+  }, [ref]);
+}
+function useEventListener(target, type, listener, options) {
+  const latest = useRef(listener);
+  latest.current = listener;
+  useEffect(() => {
+    if (!target) return void 0;
+    const handle = (event) => latest.current(event);
+    target.addEventListener(type, handle, options);
+    return () => {
+      target.removeEventListener(type, handle, options);
+    };
+  }, [target, type, options]);
+}
+function useClipboard() {
+  const isSupported = typeof navigator !== "undefined" && !!navigator.clipboard && !!navigator.clipboard.writeText;
+  const copy = useCallback(async (text) => {
+    try {
+      if (isSupported && typeof navigator !== "undefined") {
+        await navigator.clipboard.writeText(text);
+        return true;
+      }
+      if (typeof document !== "undefined") {
+        const textarea = document.createElement("textarea");
+        textarea.value = text;
+        textarea.setAttribute("readonly", "");
+        textarea.style.position = "absolute";
+        textarea.style.position = "fixed";
+        textarea.style.opacity = "0";
+        document.body.appendChild(textarea);
+        textarea.select();
+        try {
+          document.execCommand("copy");
+        } finally {
+          document.body.removeChild(textarea);
+        }
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }, [isSupported]);
+  return { copy, isSupported };
+}
+function useOnlineStatus() {
+  const [online, setOnline] = useState(
+    () => typeof navigator !== "undefined" ? navigator.onLine : true
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    setOnline(navigator.onLine);
+    const onOnline = () => setOnline(true);
+    const onOffline = () => setOnline(false);
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    return () => {
+      window.removeEventListener("online", onOnline);
+      window.removeEventListener("offline", onOffline);
+    };
+  }, []);
+  return online;
+}
+function useTimeout(callback, delay) {
+  const latest = useLatest(callback);
+  const timerRef = useRef(null);
+  const [active, setActive] = useState(false);
+  const stop = useCallback(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    setActive(false);
+  }, []);
+  const start = useCallback(() => {
+    stop();
+    if (delay !== null && delay >= 0) {
+      timerRef.current = setTimeout(() => {
+        timerRef.current = null;
+        setActive(false);
+        latest.current();
+      }, delay);
+      setActive(true);
+    }
+  }, [delay]);
+  const reset = useCallback(() => {
+    start();
+  }, [start]);
+  useEffect(() => {
+    start();
+    return () => stop();
+  }, [delay, start, stop]);
+  return { start, stop, reset, active };
+}
+function useInterval(callback, delay) {
+  const latest = useLatest(callback);
+  const timerRef = useRef(null);
+  const [active, setActive] = useState(false);
+  const stop = useCallback(() => {
+    if (timerRef.current !== null) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    setActive(false);
+  }, []);
+  const start = useCallback(() => {
+    stop();
+    if (delay !== null && delay >= 0) {
+      timerRef.current = setInterval(() => latest.current(), delay);
+      setActive(true);
+    }
+  }, [delay]);
+  useEffect(() => {
+    start();
+    return () => stop();
+  }, [delay, start, stop]);
+  return { start, stop, active };
+}
+function useAsync(asyncFn, immediate = true) {
+  const [state, setState] = useState({
+    data: null,
+    error: null,
+    isLoading: false,
+    isSuccess: false,
+    isError: false
+  });
+  const latest = useLatest(asyncFn);
+  const abortRef = useRef(null);
+  const seqRef = useRef(0);
+  const cancel = useCallback(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+      setState({ data: null, error: null, isLoading: false, isSuccess: false, isError: false });
+    }
+  }, []);
+  const setData = useCallback((data) => {
+    setState({ data, error: null, isLoading: false, isSuccess: true, isError: false });
+  }, []);
+  const setError = useCallback((error) => {
+    setState({ data: null, error, isLoading: false, isSuccess: false, isError: true });
+  }, []);
+  const reset = useCallback(() => {
+    cancel();
+    setState({ data: null, error: null, isLoading: false, isSuccess: false, isError: false });
+  }, [cancel]);
+  const execute = useCallback(async () => {
+    cancel();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    const seq = ++seqRef.current;
+    setState({ data: null, error: null, isLoading: true, isSuccess: false, isError: false });
+    try {
+      const data = await latest.current();
+      if (controller.signal.aborted || seq !== seqRef.current) return;
+      setState({ data, error: null, isLoading: false, isSuccess: true, isError: false });
+    } catch (err) {
+      if (controller.signal.aborted || seq !== seqRef.current) return;
+      const error = err instanceof Error ? err : new Error(String(err));
+      setState({ data: null, error, isLoading: false, isSuccess: false, isError: true });
+    } finally {
+      if (abortRef.current === controller) abortRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    if (!immediate) return;
+    void execute();
+    return () => cancel();
+  }, [immediate, execute, cancel]);
+  return { ...state, execute, setData, setError, reset, cancel };
+}
+
+export { useArray, useAsync, useBoolean, useClickOutside, useClipboard, useCounter, useDebouncedCallback, useDebouncedValue, useEventListener, useInterval, useLatest, useLocalStorage, useMediaQuery, useMounted, useObject, useOnlineStatus, usePrevious, useSessionStorage, useThrottle, useTimeout, useToggle, useWindowSize };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map