@mwakidenis/logx-react 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1066 @@
+'use strict';
+
+var react = require('react');
+var _function = require('@mwakidenis/logx/function');
+var browser = require('@mwakidenis/logx/browser');
+var validation = require('@mwakidenis/logx/validation');
+var object = require('@mwakidenis/logx/object');
+var number = require('@mwakidenis/logx/number');
+var array = require('@mwakidenis/logx/array');
+var async = require('@mwakidenis/logx/async');
+var date = require('@mwakidenis/logx/date');
+var string = require('@mwakidenis/logx/string');
+var jsxRuntime = require('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] = react.useState(!!initialValue);
+  const toggle = react.useCallback(() => setValue((current) => !current), []);
+  const setTrue = react.useCallback(() => setValue(true), []);
+  const setFalse = react.useCallback(() => setValue(false), []);
+  const set3 = react.useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { toggle, set: set3, setTrue, setFalse }];
+}
+function useBoolean(initialValue = false) {
+  const [value, setValue] = react.useState(!!initialValue);
+  const setTrue = react.useCallback(() => setValue(true), []);
+  const setFalse = react.useCallback(() => setValue(false), []);
+  const toggle = react.useCallback(() => setValue((current) => !current), []);
+  const set3 = react.useCallback(
+    (next) => setValue((current) => typeof next === "boolean" ? next : !current),
+    []
+  );
+  return [value, { setTrue, setFalse, toggle, set: set3 }];
+}
+function useCounter(initialValue = 0) {
+  const [count, setCount] = react.useState(initialValue);
+  const increment = react.useCallback(
+    (step = 1) => setCount((current) => current + step),
+    []
+  );
+  const decrement = react.useCallback(
+    (step = 1) => setCount((current) => current - step),
+    []
+  );
+  const reset = react.useCallback(() => setCount(initialValue), [initialValue]);
+  const set3 = react.useCallback((value) => setCount(value), []);
+  return { count, increment, decrement, reset, set: set3 };
+}
+function usePrevious(value) {
+  const ref = react.useRef(void 0);
+  react.useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+function useLatest(value) {
+  const ref = react.useRef(value);
+  ref.current = value;
+  return ref;
+}
+function useMounted() {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+    return () => setMounted(false);
+  }, []);
+  return mounted;
+}
+
+// src/internal/logx.ts
+var logx_exports = {};
+__export(logx_exports, {
+  addDays: () => date.addDays,
+  camelCase: () => string.camelCase,
+  capitalize: () => string.capitalize,
+  chunk: () => array.chunk,
+  clamp: () => number.clamp,
+  clone: () => object.clone,
+  compact: () => array.compact,
+  createLogxDebounce: () => createLogxDebounce,
+  debounce: () => _function.debounce,
+  deepClone: () => object.deepClone,
+  difference: () => array.difference,
+  drop: () => array.drop,
+  entries: () => object.entries,
+  escapeHtml: () => string.escapeHtml,
+  first: () => array.first,
+  flatten: () => array.flatten,
+  flattenDeep: () => array.flattenDeep,
+  get: () => object.get,
+  has: () => object.has,
+  hasLocalStorage: () => browser.hasLocalStorage,
+  hasSessionStorage: () => browser.hasSessionStorage,
+  inRange: () => number.inRange,
+  intersection: () => array.intersection,
+  invert: () => object.invert,
+  isArray: () => validation.isArray,
+  isBoolean: () => validation.isBoolean,
+  isBrowser: () => browser.isBrowser,
+  isEmail: () => validation.isEmail,
+  isEmpty: () => validation.isEmpty,
+  isFunction: () => validation.isFunction,
+  isNil: () => validation.isNil,
+  isNode: () => browser.isNode,
+  isNull: () => validation.isNull,
+  isNumber: () => validation.isNumber,
+  isObject: () => validation.isObject,
+  isString: () => validation.isString,
+  isURL: () => validation.isURL,
+  isValidDate: () => date.isValidDate,
+  kebabCase: () => string.kebabCase,
+  keys: () => object.keys,
+  last: () => array.last,
+  localStorageHelpers: () => browser.localStorageHelpers,
+  mapKeys: () => object.mapKeys,
+  mapValues: () => object.mapValues,
+  merge: () => object.merge,
+  omit: () => object.omit,
+  partition: () => array.partition,
+  pascalCase: () => string.pascalCase,
+  percentage: () => number.percentage,
+  pick: () => object.pick,
+  randomInt: () => number.randomInt,
+  retry: () => async.retry,
+  round: () => number.round,
+  safeStorage: () => browser.safeStorage,
+  sample: () => array.sample,
+  sessionStorageHelpers: () => browser.sessionStorageHelpers,
+  set: () => object.set,
+  shuffle: () => array.shuffle,
+  sleep: () => async.sleep,
+  snakeCase: () => string.snakeCase,
+  take: () => array.take,
+  throttle: () => _function.throttle,
+  timeout: () => async.timeout,
+  trim: () => string.trim,
+  truncate: () => string.truncate,
+  union: () => array.union,
+  unique: () => array.unique,
+  values: () => object.values,
+  withTimeout: () => async.withTimeout
+});
+function createLogxDebounce(func, wait) {
+  if (!Number.isFinite(wait) || wait < 0) {
+    throw new RangeError("debounce: wait must be a non-negative number");
+  }
+  const debounced = _function.debounce(func, wait);
+  return {
+    fn: debounced,
+    cancel: () => debounced.cancel(),
+    flush: () => debounced.flush(),
+    pending: () => debounced.pending()
+  };
+}
+
+// src/hooks/useArray.ts
+function useArray(initialValue = []) {
+  const [array$1, setArray] = react.useState(initialValue);
+  const set3 = react.useCallback(
+    (value) => setArray(
+      (prev) => typeof value === "function" ? value(prev) : value
+    ),
+    []
+  );
+  const push = react.useCallback((...items) => setArray((prev) => [...prev, ...items]), []);
+  const unshift = react.useCallback((...items) => setArray((prev) => [...items, ...prev]), []);
+  const remove = react.useCallback(
+    (index) => setArray((prev) => prev.filter((_, i) => i !== index)),
+    []
+  );
+  const removeBy = react.useCallback(
+    (predicate) => setArray((prev) => prev.filter((v, i) => !predicate(v, i))),
+    []
+  );
+  const update = react.useCallback(
+    (index, value) => setArray((prev) => prev.map((v, i) => i === index ? value : v)),
+    []
+  );
+  const clear = react.useCallback(() => setArray([]), []);
+  const reset = react.useCallback(() => setArray(initialValue), [initialValue]);
+  const unique3 = react.useCallback(() => setArray((prev) => array.unique(prev)), []);
+  const compact3 = react.useCallback(() => setArray((prev) => array.compact(prev)), []);
+  const shuffle3 = react.useCallback(() => setArray((prev) => array.shuffle(prev)), []);
+  const firstValue = react.useCallback(() => array.first(array$1), [array$1]);
+  const lastValue = react.useCallback(() => array.last(array$1), [array$1]);
+  const takeValue = react.useCallback(
+    (count) => array.take(array$1, count),
+    [array$1]
+  );
+  const dropValue = react.useCallback(
+    (count) => array.drop(array$1, count),
+    [array$1]
+  );
+  return {
+    array: array$1,
+    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: react.useCallback(
+      (...others) => array.difference(array$1, ...others),
+      [array$1]
+    ),
+    intersection: react.useCallback(
+      (...others) => array.intersection(array$1, ...others),
+      [array$1]
+    ),
+    union: react.useCallback(
+      (...others) => array.union(array$1, ...others),
+      [array$1]
+    ),
+    partition: react.useCallback(
+      (predicate) => array.partition(array$1, predicate),
+      [array$1]
+    ),
+    flatten: react.useCallback(() => array.flatten(array$1), [array$1])
+  };
+}
+function useObject(initialValue = {}) {
+  const [object$1, setObject] = react.useState(initialValue);
+  const set3 = react.useCallback(
+    (value) => setObject(
+      (prev) => typeof value === "function" ? value(prev) : value
+    ),
+    []
+  );
+  const setKey = react.useCallback(
+    (key, value) => setObject((prev) => ({ ...prev, [key]: value })),
+    []
+  );
+  const removeKey = react.useCallback(
+    (key) => setObject((prev) => {
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    }),
+    []
+  );
+  const clear = react.useCallback(() => setObject({}), []);
+  const reset = react.useCallback(() => setObject(initialValue), [initialValue]);
+  const pickValue = react.useCallback(
+    (pickedKeys) => object.pick(object$1, pickedKeys),
+    [object$1]
+  );
+  const omitValue = react.useCallback(
+    (omittedKeys) => object.omit(object$1, omittedKeys),
+    [object$1]
+  );
+  const mergeValue = react.useCallback(
+    (sources) => object.merge(object$1, ...sources),
+    [object$1]
+  );
+  const getValue = react.useCallback(
+    (path) => object.get(object$1, path),
+    [object$1]
+  );
+  const keysValue = react.useCallback(() => object.keys(object$1), [object$1]);
+  const valuesValue = react.useCallback(() => object.values(object$1), [object$1]);
+  const entriesValue = react.useCallback(() => object.entries(object$1), [object$1]);
+  const cloneValue = react.useCallback(() => object.clone(object$1), [object$1]);
+  const deepCloneValue = react.useCallback(() => object.deepClone(object$1), [object$1]);
+  const mapValuesValue = react.useCallback(
+    (iteratee) => object.mapValues(object$1, iteratee),
+    [object$1]
+  );
+  return {
+    object: object$1,
+    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] = react.useState(value);
+  const latest = useLatest(value);
+  const timerRef = react.useRef(null);
+  const lastLeadingRef = react.useRef(void 0);
+  react.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]);
+  react.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 = react.useRef(null);
+  react.useEffect(() => {
+    const debounced = _function.debounce(
+      (...args) => {
+        latest.current(...args);
+      },
+      delay
+    );
+    debouncedRef.current = debounced;
+    return () => {
+      debounced.cancel();
+    };
+  }, [delay]);
+  const invoke = react.useCallback((...args) => {
+    debouncedRef.current?.(...args);
+  }, []);
+  const cancel = react.useCallback(() => {
+    debouncedRef.current?.cancel();
+  }, []);
+  const flush = react.useCallback(() => {
+    debouncedRef.current?.flush();
+  }, []);
+  const pending = react.useCallback(() => debouncedRef.current?.pending() ?? false, []);
+  return Object.assign(invoke, { cancel, flush, pending });
+}
+function useThrottle(callback, wait) {
+  const latest = useLatest(callback);
+  const throttledRef = react.useRef(null);
+  react.useEffect(() => {
+    const throttled = _function.throttle(
+      (...args) => {
+        latest.current(...args);
+      },
+      wait
+    );
+    throttledRef.current = throttled;
+    return () => {
+      throttled.cancel();
+    };
+  }, [wait]);
+  const invoke = react.useCallback((...args) => {
+    throttledRef.current?.(...args);
+  }, []);
+  const cancel = react.useCallback(() => {
+    throttledRef.current?.cancel();
+  }, []);
+  const flush = react.useCallback(() => {
+    throttledRef.current?.flush();
+  }, []);
+  const pending = react.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] = react.useState(initialValue);
+  react.useEffect(() => {
+    const helpers = browser.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 = react.useCallback(
+    (next) => setValue((prev) => {
+      const resolved = typeof next === "function" ? next(prev) : next;
+      const helpers = browser.localStorageHelpers();
+      if (helpers) {
+        try {
+          helpers.set(key, serializer.serialize(resolved));
+        } catch {
+        }
+      }
+      return resolved;
+    }),
+    [key, serializer]
+  );
+  const remove = react.useCallback(() => {
+    setValue(initialValue);
+    const helpers = browser.localStorageHelpers();
+    if (helpers) {
+      try {
+        helpers.remove(key);
+      } catch {
+      }
+    }
+  }, [key, initialValue]);
+  react.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] = react.useState(initialValue);
+  react.useEffect(() => {
+    const helpers = browser.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 = react.useCallback(
+    (next) => setValue((prev) => {
+      const resolved = typeof next === "function" ? next(prev) : next;
+      const helpers = browser.sessionStorageHelpers();
+      if (helpers) {
+        try {
+          helpers.set(key, serializer.serialize(resolved));
+        } catch {
+        }
+      }
+      return resolved;
+    }),
+    [key, serializer]
+  );
+  const remove = react.useCallback(() => {
+    setValue(initialValue);
+    const helpers = browser.sessionStorageHelpers();
+    if (helpers) {
+      try {
+        helpers.remove(key);
+      } catch {
+      }
+    }
+  }, [key, initialValue]);
+  return [value, set3, remove];
+}
+function useMediaQuery(query) {
+  const [matches, setMatches] = react.useState(false);
+  react.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] = react.useState(
+    () => typeof window !== "undefined" ? { width: window.innerWidth, height: window.innerHeight } : { width: 0, height: 0 }
+  );
+  react.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 = react.useRef(handler);
+  latest.current = handler;
+  react.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 = react.useRef(listener);
+  latest.current = listener;
+  react.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 = react.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] = react.useState(
+    () => typeof navigator !== "undefined" ? navigator.onLine : true
+  );
+  react.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 = react.useRef(null);
+  const [active, setActive] = react.useState(false);
+  const stop = react.useCallback(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    setActive(false);
+  }, []);
+  const start = react.useCallback(() => {
+    stop();
+    if (delay !== null && delay >= 0) {
+      timerRef.current = setTimeout(() => {
+        timerRef.current = null;
+        setActive(false);
+        latest.current();
+      }, delay);
+      setActive(true);
+    }
+  }, [delay]);
+  const reset = react.useCallback(() => {
+    start();
+  }, [start]);
+  react.useEffect(() => {
+    start();
+    return () => stop();
+  }, [delay, start, stop]);
+  return { start, stop, reset, active };
+}
+function useInterval(callback, delay) {
+  const latest = useLatest(callback);
+  const timerRef = react.useRef(null);
+  const [active, setActive] = react.useState(false);
+  const stop = react.useCallback(() => {
+    if (timerRef.current !== null) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    setActive(false);
+  }, []);
+  const start = react.useCallback(() => {
+    stop();
+    if (delay !== null && delay >= 0) {
+      timerRef.current = setInterval(() => latest.current(), delay);
+      setActive(true);
+    }
+  }, [delay]);
+  react.useEffect(() => {
+    start();
+    return () => stop();
+  }, [delay, start, stop]);
+  return { start, stop, active };
+}
+function useAsync(asyncFn, immediate = true) {
+  const [state, setState] = react.useState({
+    data: null,
+    error: null,
+    isLoading: false,
+    isSuccess: false,
+    isError: false
+  });
+  const latest = useLatest(asyncFn);
+  const abortRef = react.useRef(null);
+  const seqRef = react.useRef(0);
+  const cancel = react.useCallback(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+      setState({ data: null, error: null, isLoading: false, isSuccess: false, isError: false });
+    }
+  }, []);
+  const setData = react.useCallback((data) => {
+    setState({ data, error: null, isLoading: false, isSuccess: true, isError: false });
+  }, []);
+  const setError = react.useCallback((error) => {
+    setState({ data: null, error, isLoading: false, isSuccess: false, isError: true });
+  }, []);
+  const reset = react.useCallback(() => {
+    cancel();
+    setState({ data: null, error: null, isLoading: false, isSuccess: false, isError: false });
+  }, [cancel]);
+  const execute = react.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;
+    }
+  }, []);
+  react.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] = react.useState("idle");
+  const { copy } = useClipboard();
+  const handleCopy = react.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__ */ jsxRuntime.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] = react.useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value ?? "" : internalValue;
+  const handleChange = react.useCallback(
+    (event) => {
+      const next = event.target.value;
+      if (!isControlled) setInternalValue(next);
+      onChange?.(next);
+    },
+    [isControlled, onChange]
+  );
+  const debounced = useDebouncedValue(currentValue, { delay });
+  const initialized = react.useRef(false);
+  react.useEffect(() => {
+    if (!initialized.current) {
+      initialized.current = true;
+      return;
+    }
+    onDebouncedChange?.(debounced);
+  }, [debounced, onDebouncedChange]);
+  return /* @__PURE__ */ jsxRuntime.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] = react.useState(false);
+  const [internalValue, setInternalValue] = react.useState(defaultValue ?? "");
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value ?? "" : internalValue;
+  const handleChange = react.useCallback(
+    (event) => {
+      const next = event.target.value;
+      if (!isControlled) setInternalValue(next);
+      onChange?.(next);
+    },
+    [isControlled, onChange]
+  );
+  const toggle = react.useCallback(() => setShow((current) => !current), []);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, children: [
+    label && /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id,
+        name,
+        type: show ? "text" : "password",
+        value: currentValue,
+        onChange: handleChange,
+        placeholder,
+        disabled,
+        required: required2,
+        "aria-label": label
+      }
+    ),
+    showToggle && /* @__PURE__ */ jsxRuntime.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 = react.useCallback(
+    (m) => m ? children(m) : fallback ?? null,
+    [children, fallback]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderChildren(matches) });
+}
+var ErrorBoundary = class extends react.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 = array.chunk;
+var compact2 = array.compact;
+var difference2 = array.difference;
+var drop2 = array.drop;
+var flatten2 = array.flatten;
+var flattenDeep2 = array.flattenDeep;
+var intersection2 = array.intersection;
+var last2 = array.last;
+var partition2 = array.partition;
+var sample2 = array.sample;
+var shuffle2 = array.shuffle;
+var take2 = array.take;
+var union2 = array.union;
+var unique2 = array.unique;
+function first2(array) {
+  return array[0];
+}
+function distinct(array) {
+  return unique2(array);
+}
+
+// src/utilities/object.ts
+var clone2 = object.clone;
+var deepClone2 = object.deepClone;
+var entries2 = object.entries;
+var get2 = object.get;
+var has2 = object.has;
+var keys2 = object.keys;
+var mapKeys2 = object.mapKeys;
+var mapValues2 = object.mapValues;
+var merge2 = object.merge;
+var omit2 = object.omit;
+var pick2 = object.pick;
+var set2 = object.set;
+var values2 = object.values;
+function safeGet(object$1, path) {
+  const result = object.get(object$1, path);
+  return result === void 0 ? void 0 : result;
+}
+
+// src/utilities/string.ts
+var camelCase2 = string.camelCase;
+var capitalize2 = string.capitalize;
+var escapeHtml2 = string.escapeHtml;
+var kebabCase2 = string.kebabCase;
+var pascalCase2 = string.pascalCase;
+var snakeCase2 = string.snakeCase;
+var trim2 = string.trim;
+var truncate2 = string.truncate;
+function htmlEscape(input) {
+  return escapeHtml2(input);
+}
+
+// src/utilities/number.ts
+var clamp2 = number.clamp;
+var inRange2 = number.inRange;
+var round2 = number.round;
+var percentage2 = number.percentage;
+var randomInt2 = number.randomInt;
+
+// src/utilities/validation.ts
+var isArray2 = validation.isArray;
+var isBoolean2 = validation.isBoolean;
+var isEmail2 = validation.isEmail;
+var isEmpty2 = validation.isEmpty;
+var isFunction2 = validation.isFunction;
+var isNil2 = validation.isNil;
+var isNull2 = validation.isNull;
+var isNumber2 = validation.isNumber;
+var isObject2 = validation.isObject;
+var isString2 = validation.isString;
+var isURL2 = validation.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 = date.addDays;
+var isValidDate2 = date.isValidDate;
+
+// src/utilities/browser.ts
+var hasLocalStorage = browser.hasLocalStorage;
+var hasSessionStorage = browser.hasSessionStorage;
+var isBrowser = browser.isBrowser;
+var isNode = browser.isNode;
+var LogxContext = react.createContext(null);
+function LogxProvider({ children }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(LogxContext.Provider, { value: { logx: logx_exports }, children });
+}
+function useLogx() {
+  return react.useContext(LogxContext);
+}
+
+exports.CopyButton = CopyButton;
+exports.DebouncedInput = DebouncedInput;
+exports.ErrorBoundary = ErrorBoundary;
+exports.LogxProvider = LogxProvider;
+exports.PasswordInput = PasswordInput;
+exports.Responsive = Responsive;
+exports.addDays = addDays2;
+exports.camelCase = camelCase2;
+exports.capitalize = capitalize2;
+exports.chunk = chunk2;
+exports.clamp = clamp2;
+exports.clone = clone2;
+exports.compact = compact2;
+exports.deepClone = deepClone2;
+exports.difference = difference2;
+exports.distinct = distinct;
+exports.drop = drop2;
+exports.entries = entries2;
+exports.escapeHtml = escapeHtml2;
+exports.first = first2;
+exports.flatten = flatten2;
+exports.flattenDeep = flattenDeep2;
+exports.get = get2;
+exports.has = has2;
+exports.hasLocalStorage = hasLocalStorage;
+exports.hasSessionStorage = hasSessionStorage;
+exports.htmlEscape = htmlEscape;
+exports.inRange = inRange2;
+exports.intersection = intersection2;
+exports.isArray = isArray2;
+exports.isBoolean = isBoolean2;
+exports.isBrowser = isBrowser;
+exports.isEmail = isEmail2;
+exports.isEmpty = isEmpty2;
+exports.isFunction = isFunction2;
+exports.isNil = isNil2;
+exports.isNode = isNode;
+exports.isNull = isNull2;
+exports.isNumber = isNumber2;
+exports.isObject = isObject2;
+exports.isString = isString2;
+exports.isURL = isURL2;
+exports.isValidDate = isValidDate2;
+exports.kebabCase = kebabCase2;
+exports.keys = keys2;
+exports.last = last2;
+exports.mapKeys = mapKeys2;
+exports.mapValues = mapValues2;
+exports.merge = merge2;
+exports.omit = omit2;
+exports.partition = partition2;
+exports.pascalCase = pascalCase2;
+exports.percentage = percentage2;
+exports.pick = pick2;
+exports.randomInt = randomInt2;
+exports.required = required;
+exports.round = round2;
+exports.safeGet = safeGet;
+exports.sample = sample2;
+exports.set = set2;
+exports.shuffle = shuffle2;
+exports.snakeCase = snakeCase2;
+exports.take = take2;
+exports.trim = trim2;
+exports.truncate = truncate2;
+exports.union = union2;
+exports.unique = unique2;
+exports.useArray = useArray;
+exports.useAsync = useAsync;
+exports.useBoolean = useBoolean;
+exports.useClickOutside = useClickOutside;
+exports.useClipboard = useClipboard;
+exports.useCounter = useCounter;
+exports.useDebouncedCallback = useDebouncedCallback;
+exports.useDebouncedValue = useDebouncedValue;
+exports.useEventListener = useEventListener;
+exports.useInterval = useInterval;
+exports.useLatest = useLatest;
+exports.useLocalStorage = useLocalStorage;
+exports.useLogx = useLogx;
+exports.useMediaQuery = useMediaQuery;
+exports.useMounted = useMounted;
+exports.useObject = useObject;
+exports.useOnlineStatus = useOnlineStatus;
+exports.usePrevious = usePrevious;
+exports.useSessionStorage = useSessionStorage;
+exports.useThrottle = useThrottle;
+exports.useTimeout = useTimeout;
+exports.useToggle = useToggle;
+exports.useWindowSize = useWindowSize;
+exports.values = values2;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map