@mwakidenis/logx-react 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,974 @@
+import { createContext, useState, useCallback, useRef, useEffect, Component, useContext } from 'react';
+import { throttle, debounce } from '@mwakidenis/logx/function';
+import { hasLocalStorage as hasLocalStorage$1, hasSessionStorage as hasSessionStorage$1, isBrowser as isBrowser$1, isNode as isNode$1, sessionStorageHelpers, safeStorage, localStorageHelpers } from '@mwakidenis/logx/browser';
+import { isArray, isBoolean, isEmail, isEmpty, isFunction, isNil, isNull, isNumber, isObject, isString, isURL } from '@mwakidenis/logx/validation';
+import { clone, deepClone, entries, get, has, keys, mapKeys, mapValues, merge, omit, pick, set, values, invert } from '@mwakidenis/logx/object';
+import { clamp, inRange, percentage, randomInt, round } from '@mwakidenis/logx/number';
+import { chunk, compact, difference, drop, flatten, flattenDeep, intersection, last, partition, sample, shuffle, take, union, unique, first } from '@mwakidenis/logx/array';
+import { withTimeout, timeout, sleep, retry } from '@mwakidenis/logx/async';
+import { addDays, isValidDate } from '@mwakidenis/logx/date';
+import { camelCase, capitalize, escapeHtml, kebabCase, pascalCase, snakeCase, trim, truncate } from '@mwakidenis/logx/string';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 set3 = useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { toggle, set: set3, 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 set3 = useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { setTrue, setFalse, toggle, set: set3 }];
+}
+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 set3 = useCallback((value) => setCount(value), []);
+  return { count, increment, decrement, reset, set: set3 };
+}
+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/internal/logx.ts
+var logx_exports = {};
+__export(logx_exports, {
+  addDays: () => addDays,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  chunk: () => chunk,
+  clamp: () => clamp,
+  clone: () => clone,
+  compact: () => compact,
+  createLogxDebounce: () => createLogxDebounce,
+  debounce: () => debounce,
+  deepClone: () => deepClone,
+  difference: () => difference,
+  drop: () => drop,
+  entries: () => entries,
+  escapeHtml: () => escapeHtml,
+  first: () => first,
+  flatten: () => flatten,
+  flattenDeep: () => flattenDeep,
+  get: () => get,
+  has: () => has,
+  hasLocalStorage: () => hasLocalStorage$1,
+  hasSessionStorage: () => hasSessionStorage$1,
+  inRange: () => inRange,
+  intersection: () => intersection,
+  invert: () => invert,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isBrowser: () => isBrowser$1,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isFunction: () => isFunction,
+  isNil: () => isNil,
+  isNode: () => isNode$1,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isString: () => isString,
+  isURL: () => isURL,
+  isValidDate: () => isValidDate,
+  kebabCase: () => kebabCase,
+  keys: () => keys,
+  last: () => last,
+  localStorageHelpers: () => localStorageHelpers,
+  mapKeys: () => mapKeys,
+  mapValues: () => mapValues,
+  merge: () => merge,
+  omit: () => omit,
+  partition: () => partition,
+  pascalCase: () => pascalCase,
+  percentage: () => percentage,
+  pick: () => pick,
+  randomInt: () => randomInt,
+  retry: () => retry,
+  round: () => round,
+  safeStorage: () => safeStorage,
+  sample: () => sample,
+  sessionStorageHelpers: () => sessionStorageHelpers,
+  set: () => set,
+  shuffle: () => shuffle,
+  sleep: () => sleep,
+  snakeCase: () => snakeCase,
+  take: () => take,
+  throttle: () => throttle,
+  timeout: () => timeout,
+  trim: () => trim,
+  truncate: () => truncate,
+  union: () => union,
+  unique: () => unique,
+  values: () => values,
+  withTimeout: () => withTimeout
+});
+function createLogxDebounce(func, wait) {
+  if (!Number.isFinite(wait) || wait < 0) {
+    throw new RangeError("debounce: wait must be a non-negative number");
+  }
+  const debounced = debounce(func, wait);
+  return {
+    fn: debounced,
+    cancel: () => debounced.cancel(),
+    flush: () => debounced.flush(),
+    pending: () => debounced.pending()
+  };
+}
+
+// src/hooks/useArray.ts
+function useArray(initialValue = []) {
+  const [array, setArray] = useState(initialValue);
+  const set3 = 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 unique3 = useCallback(() => setArray((prev) => unique(prev)), []);
+  const compact3 = useCallback(() => setArray((prev) => compact(prev)), []);
+  const shuffle3 = 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: set3,
+    push,
+    unshift,
+    remove,
+    removeBy,
+    update,
+    clear,
+    reset,
+    unique: unique3,
+    compact: compact3,
+    shuffle: shuffle3,
+    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 set3 = 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: set3,
+    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 set3 = 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, set3, 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 set3 = 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, set3, 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 };
+}
+function CopyButton({
+  text,
+  label = "Copy",
+  copyingLabel = "Copying...",
+  successLabel = "Copied!",
+  errorLabel = "Error",
+  className,
+  onCopy,
+  onError,
+  timeout: timeout2 = 2e3
+}) {
+  const [status, setStatus] = useState("idle");
+  const { copy } = useClipboard();
+  const handleCopy = useCallback(async () => {
+    setStatus("copying");
+    try {
+      const ok = await copy(text);
+      if (ok) {
+        setStatus("success");
+        onCopy?.(text);
+      } else {
+        setStatus("error");
+        onError?.(new Error("Failed to copy to clipboard"));
+      }
+    } catch (err) {
+      setStatus("error");
+      onError?.(err);
+    }
+    setTimeout(() => setStatus("idle"), timeout2);
+  }, [text, copy, onCopy, onError, timeout2]);
+  const displayLabel = status === "copying" ? copyingLabel : status === "success" ? successLabel : status === "error" ? errorLabel : label;
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className,
+      disabled: status === "copying",
+      onClick: handleCopy,
+      "aria-label": status === "success" ? "Copied to clipboard" : label,
+      "aria-pressed": status === "success",
+      children: displayLabel
+    }
+  );
+}
+function DebouncedInput({
+  value,
+  defaultValue,
+  onChange,
+  onDebouncedChange,
+  delay = 300,
+  ...rest
+}) {
+  const [internalValue, setInternalValue] = useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value ?? "" : internalValue;
+  const handleChange = useCallback(
+    (event) => {
+      const next = event.target.value;
+      if (!isControlled) setInternalValue(next);
+      onChange?.(next);
+    },
+    [isControlled, onChange]
+  );
+  const debounced = useDebouncedValue(currentValue, { delay });
+  const initialized = useRef(false);
+  useEffect(() => {
+    if (!initialized.current) {
+      initialized.current = true;
+      return;
+    }
+    onDebouncedChange?.(debounced);
+  }, [debounced, onDebouncedChange]);
+  return /* @__PURE__ */ jsx("input", { ...rest, value: currentValue, onChange: handleChange });
+}
+function PasswordInput({
+  value,
+  defaultValue,
+  onChange,
+  label = "Password",
+  placeholder,
+  disabled = false,
+  required: required2 = false,
+  name,
+  id,
+  showToggle = true,
+  className
+}) {
+  const [show, setShow] = useState(false);
+  const [internalValue, setInternalValue] = useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value ?? "" : internalValue;
+  const handleChange = useCallback(
+    (event) => {
+      const next = event.target.value;
+      if (!isControlled) setInternalValue(next);
+      onChange?.(next);
+    },
+    [isControlled, onChange]
+  );
+  const toggle = useCallback(() => setShow((current) => !current), []);
+  return /* @__PURE__ */ jsxs("div", { className, children: [
+    label && /* @__PURE__ */ jsx("label", { htmlFor: id, children: label }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id,
+        name,
+        type: show ? "text" : "password",
+        value: currentValue,
+        onChange: handleChange,
+        placeholder,
+        disabled,
+        required: required2,
+        "aria-label": label
+      }
+    ),
+    showToggle && /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: toggle,
+        "aria-label": show ? "Hide password" : "Show password",
+        "aria-pressed": show,
+        children: show ? "Hide password" : "Show password"
+      }
+    )
+  ] });
+}
+function Responsive({ children, query, fallback }) {
+  const matches = useMediaQuery(query);
+  const renderChildren = useCallback(
+    (m) => m ? children(m) : fallback ?? null,
+    [children, fallback]
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: renderChildren(matches) });
+}
+var ErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false, error: null, info: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error, info: null };
+  }
+  componentDidCatch(error, info) {
+    this.setState({ info });
+    this.props.onError?.(error, info);
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.resetKeys !== prevProps.resetKeys) {
+      const prev = JSON.stringify(prevProps.resetKeys);
+      const next = JSON.stringify(this.props.resetKeys);
+      if (prev !== next) {
+        this.setState({ hasError: false, error: null, info: null });
+      }
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      const { fallback } = this.props;
+      if (fallback === void 0) return null;
+      if (typeof fallback === "function") {
+        return fallback(
+          this.state.error,
+          this.state.info
+        );
+      }
+      return fallback;
+    }
+    return this.props.children;
+  }
+};
+
+// src/utilities/array.ts
+var chunk2 = chunk;
+var compact2 = compact;
+var difference2 = difference;
+var drop2 = drop;
+var flatten2 = flatten;
+var flattenDeep2 = flattenDeep;
+var intersection2 = intersection;
+var last2 = last;
+var partition2 = partition;
+var sample2 = sample;
+var shuffle2 = shuffle;
+var take2 = take;
+var union2 = union;
+var unique2 = unique;
+function first2(array) {
+  return array[0];
+}
+function distinct(array) {
+  return unique2(array);
+}
+
+// src/utilities/object.ts
+var clone2 = clone;
+var deepClone2 = deepClone;
+var entries2 = entries;
+var get2 = get;
+var has2 = has;
+var keys2 = keys;
+var mapKeys2 = mapKeys;
+var mapValues2 = mapValues;
+var merge2 = merge;
+var omit2 = omit;
+var pick2 = pick;
+var set2 = set;
+var values2 = values;
+function safeGet(object, path) {
+  const result = get(object, path);
+  return result === void 0 ? void 0 : result;
+}
+
+// src/utilities/string.ts
+var camelCase2 = camelCase;
+var capitalize2 = capitalize;
+var escapeHtml2 = escapeHtml;
+var kebabCase2 = kebabCase;
+var pascalCase2 = pascalCase;
+var snakeCase2 = snakeCase;
+var trim2 = trim;
+var truncate2 = truncate;
+function htmlEscape(input) {
+  return escapeHtml2(input);
+}
+
+// src/utilities/number.ts
+var clamp2 = clamp;
+var inRange2 = inRange;
+var round2 = round;
+var percentage2 = percentage;
+var randomInt2 = randomInt;
+
+// src/utilities/validation.ts
+var isArray2 = isArray;
+var isBoolean2 = isBoolean;
+var isEmail2 = isEmail;
+var isEmpty2 = isEmpty;
+var isFunction2 = isFunction;
+var isNil2 = isNil;
+var isNull2 = isNull;
+var isNumber2 = isNumber;
+var isObject2 = isObject;
+var isString2 = isString;
+var isURL2 = isURL;
+function required(value, fieldName = "This field") {
+  if (isNil2(value)) return `${fieldName} is required`;
+  if (isString2(value) && value.trim() === "") return `${fieldName} is required`;
+  return null;
+}
+
+// src/utilities/date.ts
+var addDays2 = addDays;
+var isValidDate2 = isValidDate;
+
+// src/utilities/browser.ts
+var hasLocalStorage = hasLocalStorage$1;
+var hasSessionStorage = hasSessionStorage$1;
+var isBrowser = isBrowser$1;
+var isNode = isNode$1;
+var LogxContext = createContext(null);
+function LogxProvider({ children }) {
+  return /* @__PURE__ */ jsx(LogxContext.Provider, { value: { logx: logx_exports }, children });
+}
+function useLogx() {
+  return useContext(LogxContext);
+}
+
+export { CopyButton, DebouncedInput, ErrorBoundary, LogxProvider, PasswordInput, Responsive, addDays2 as addDays, camelCase2 as camelCase, capitalize2 as capitalize, chunk2 as chunk, clamp2 as clamp, clone2 as clone, compact2 as compact, deepClone2 as deepClone, difference2 as difference, distinct, drop2 as drop, entries2 as entries, escapeHtml2 as escapeHtml, first2 as first, flatten2 as flatten, flattenDeep2 as flattenDeep, get2 as get, has2 as has, hasLocalStorage, hasSessionStorage, htmlEscape, inRange2 as inRange, intersection2 as intersection, isArray2 as isArray, isBoolean2 as isBoolean, isBrowser, isEmail2 as isEmail, isEmpty2 as isEmpty, isFunction2 as isFunction, isNil2 as isNil, isNode, isNull2 as isNull, isNumber2 as isNumber, isObject2 as isObject, isString2 as isString, isURL2 as isURL, isValidDate2 as isValidDate, kebabCase2 as kebabCase, keys2 as keys, last2 as last, mapKeys2 as mapKeys, mapValues2 as mapValues, merge2 as merge, omit2 as omit, partition2 as partition, pascalCase2 as pascalCase, percentage2 as percentage, pick2 as pick, randomInt2 as randomInt, required, round2 as round, safeGet, sample2 as sample, set2 as set, shuffle2 as shuffle, snakeCase2 as snakeCase, take2 as take, trim2 as trim, truncate2 as truncate, union2 as union, unique2 as unique, useArray, useAsync, useBoolean, useClickOutside, useClipboard, useCounter, useDebouncedCallback, useDebouncedValue, useEventListener, useInterval, useLatest, useLocalStorage, useLogx, useMediaQuery, useMounted, useObject, useOnlineStatus, usePrevious, useSessionStorage, useThrottle, useTimeout, useToggle, useWindowSize, values2 as values };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map