react-simplikit 0.0.50 → 0.0.52

package/esm/hooks/useCounter/index.js

@@ -1,44 +0,0 @@
-"use client";
-
-// src/hooks/useCounter/useCounter.ts
-import { useCallback, useState } from "react";
-var validateValue = (value, { min, max }) => {
-  if (min !== void 0 && value < min) {
-    return min;
-  }
-  if (max !== void 0 && value > max) {
-    return max;
-  }
-  return value;
-};
-function useCounter(initialValue = 0, { min, max, step = 1 } = {}) {
-  const [count, setCountState] = useState(() => validateValue(initialValue, { min, max }));
-  const setCount = useCallback(
-    (value) => {
-      setCountState((prev) => {
-        const nextValue = typeof value === "function" ? value(prev) : value;
-        return validateValue(nextValue, { min, max });
-      });
-    },
-    [min, max]
-  );
-  const increment = useCallback(() => {
-    setCount((prev) => prev + step);
-  }, [setCount, step]);
-  const decrement = useCallback(() => {
-    setCount((prev) => prev - step);
-  }, [setCount, step]);
-  const reset = useCallback(() => {
-    setCount(initialValue);
-  }, [setCount, initialValue]);
-  return {
-    count,
-    increment,
-    decrement,
-    reset,
-    setCount
-  };
-}
-export {
-  useCounter
-};

package/esm/hooks/useDebounce/index.js

@@ -1,104 +0,0 @@
-"use client";
-
-// src/hooks/useDebounce/useDebounce.ts
-import { useEffect as useEffect2 } from "react";
-import { useMemo } from "react";
-
-// src/hooks/usePreservedCallback/usePreservedCallback.ts
-import { useCallback, useEffect, useRef } from "react";
-function usePreservedCallback(callback) {
-  const callbackRef = useRef(callback);
-  useEffect(
-    function syncCallbackRef() {
-      callbackRef.current = callback;
-    },
-    [callback]
-  );
-  return useCallback((...args) => {
-    return callbackRef.current(...args);
-  }, []);
-}
-
-// src/hooks/useDebounce/debounce.ts
-function debounce(func, debounceMs, { edges = ["leading", "trailing"] } = {}) {
-  let pendingThis = void 0;
-  let pendingArgs = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = () => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = void 0;
-      pendingArgs = null;
-    }
-  };
-  const onTimerEnd = () => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  };
-  let timeoutId = null;
-  const schedule = () => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
-    }, debounceMs);
-  };
-  const cancelTimer = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  const cancel = () => {
-    cancelTimer();
-    pendingThis = void 0;
-    pendingArgs = null;
-  };
-  const debounced = function(...args) {
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
-    }
-  };
-  debounced.cancel = cancel;
-  return debounced;
-}
-
-// src/hooks/useDebounce/useDebounce.ts
-function useDebounce(callback, wait, options = {}) {
-  const preservedCallback = usePreservedCallback(callback);
-  const { leading = false, trailing = true } = options;
-  const edges = useMemo(() => {
-    const _edges = [];
-    if (leading) {
-      _edges.push("leading");
-    }
-    if (trailing) {
-      _edges.push("trailing");
-    }
-    return _edges;
-  }, [leading, trailing]);
-  const debounced = useMemo(() => {
-    return debounce(preservedCallback, wait, { edges });
-  }, [preservedCallback, wait, edges]);
-  useEffect2(
-    function cancelDebouncedOnUnmount() {
-      return () => {
-        debounced.cancel();
-      };
-    },
-    [debounced]
-  );
-  return debounced;
-}
-export {
-  useDebounce
-};

package/esm/hooks/useDebouncedCallback/index.js

@@ -1,122 +0,0 @@
-"use client";
-
-// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
-
-// src/hooks/useDebounce/debounce.ts
-function debounce(func, debounceMs, { edges = ["leading", "trailing"] } = {}) {
-  let pendingThis = void 0;
-  let pendingArgs = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = () => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = void 0;
-      pendingArgs = null;
-    }
-  };
-  const onTimerEnd = () => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  };
-  let timeoutId = null;
-  const schedule = () => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
-    }, debounceMs);
-  };
-  const cancelTimer = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  const cancel = () => {
-    cancelTimer();
-    pendingThis = void 0;
-    pendingArgs = null;
-  };
-  const debounced = function(...args) {
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
-    }
-  };
-  debounced.cancel = cancel;
-  return debounced;
-}
-
-// src/hooks/usePreservedCallback/usePreservedCallback.ts
-import { useCallback, useEffect, useRef } from "react";
-function usePreservedCallback(callback) {
-  const callbackRef = useRef(callback);
-  useEffect(
-    function syncCallbackRef() {
-      callbackRef.current = callback;
-    },
-    [callback]
-  );
-  return useCallback((...args) => {
-    return callbackRef.current(...args);
-  }, []);
-}
-
-// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
-function useDebouncedCallback({
-  onChange,
-  timeThreshold,
-  leading = false,
-  trailing = true
-}) {
-  const handleChange = usePreservedCallback(onChange);
-  const ref = useRef2({ value: false, clearPreviousDebounce: () => {
-  } });
-  useEffect2(function clearDebouncedOnUnmount() {
-    const current = ref.current;
-    return () => {
-      current.clearPreviousDebounce();
-    };
-  }, []);
-  const edges = useMemo(() => {
-    const _edges = [];
-    if (leading) {
-      _edges.push("leading");
-    }
-    if (trailing) {
-      _edges.push("trailing");
-    }
-    return _edges;
-  }, [leading, trailing]);
-  return useCallback2(
-    (nextValue) => {
-      if (nextValue === ref.current.value) {
-        return;
-      }
-      const debounced = debounce(
-        () => {
-          handleChange(nextValue);
-          ref.current.value = nextValue;
-        },
-        timeThreshold,
-        { edges }
-      );
-      ref.current.clearPreviousDebounce();
-      debounced();
-      ref.current.clearPreviousDebounce = debounced.cancel;
-    },
-    [handleChange, timeThreshold, edges]
-  );
-}
-export {
-  useDebouncedCallback
-};

package/esm/hooks/useDoubleClick/index.js

@@ -1,53 +0,0 @@
-"use client";
-
-// src/hooks/useDoubleClick/useDoubleClick.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2 } from "react";
-
-// src/hooks/usePreservedCallback/usePreservedCallback.ts
-import { useCallback, useEffect, useRef } from "react";
-function usePreservedCallback(callback) {
-  const callbackRef = useRef(callback);
-  useEffect(
-    function syncCallbackRef() {
-      callbackRef.current = callback;
-    },
-    [callback]
-  );
-  return useCallback((...args) => {
-    return callbackRef.current(...args);
-  }, []);
-}
-
-// src/hooks/useDoubleClick/useDoubleClick.ts
-function useDoubleClick({
-  delay = 250,
-  click,
-  doubleClick
-}) {
-  const clickTimeout = useRef2(null);
-  const clearClickTimeout = usePreservedCallback(() => {
-    if (clickTimeout.current != null) {
-      window.clearTimeout(clickTimeout.current);
-      clickTimeout.current = null;
-    }
-  });
-  useEffect2(() => () => clearClickTimeout(), [clearClickTimeout]);
-  const handleEvent = useCallback2(
-    (event) => {
-      clearClickTimeout();
-      if (click && event.detail === 1) {
-        clickTimeout.current = window.setTimeout(() => {
-          click(event);
-        }, delay);
-      }
-      if (event.detail === 2) {
-        doubleClick(event);
-      }
-    },
-    [click, doubleClick, delay, clearClickTimeout]
-  );
-  return handleEvent;
-}
-export {
-  useDoubleClick
-};

package/esm/hooks/useGeolocation/index.js

@@ -1,128 +0,0 @@
-"use client";
-
-// src/hooks/useGeolocation/useGeolocation.ts
-import { useCallback, useEffect, useRef, useState } from "react";
-var CustomGeoLocationError = class extends Error {
-  code;
-  constructor({ code, message }) {
-    super(message);
-    this.name = "CustomGeoLocationError";
-    this.code = code;
-  }
-};
-var GeolocationMountBehavior = {
-  GET: "get",
-  WATCH: "watch"
-};
-function useGeolocation(options) {
-  const [state, setState] = useState({
-    loading: !!options?.mountBehavior,
-    error: null,
-    data: null
-  });
-  const [isTracking, setIsTracking] = useState(false);
-  const watchIdRef = useRef(null);
-  const checkGeolocationSupport = useCallback(() => {
-    if (typeof window === "undefined" || navigator.geolocation === void 0) {
-      setState((prev) => ({
-        ...prev,
-        loading: false,
-        error: new CustomGeoLocationError({
-          code: 0,
-          message: "Geolocation is not supported by this environment."
-        })
-      }));
-      return false;
-    }
-    return true;
-  }, []);
-  const handleSuccess = useCallback((position) => {
-    const { coords } = position;
-    setState((prev) => ({
-      ...prev,
-      loading: false,
-      error: null,
-      data: {
-        latitude: coords.latitude,
-        longitude: coords.longitude,
-        accuracy: coords.accuracy,
-        altitude: coords.altitude,
-        altitudeAccuracy: coords.altitudeAccuracy,
-        heading: coords.heading,
-        speed: coords.speed,
-        timestamp: position.timestamp
-      }
-    }));
-  }, []);
-  const handleError = useCallback((error) => {
-    const { code, message } = error;
-    setState((prev) => ({
-      ...prev,
-      loading: false,
-      error: new CustomGeoLocationError({ code, message })
-    }));
-  }, []);
-  const getGeolocationOptions = useCallback(
-    () => ({
-      enableHighAccuracy: options?.enableHighAccuracy,
-      maximumAge: options?.maximumAge,
-      timeout: options?.timeout
-    }),
-    [options?.enableHighAccuracy, options?.maximumAge, options?.timeout]
-  );
-  const getCurrentPosition = useCallback(() => {
-    if (!checkGeolocationSupport()) {
-      return;
-    }
-    setState((prev) => ({ ...prev, loading: true }));
-    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
-  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
-  const startTracking = useCallback(() => {
-    if (!checkGeolocationSupport()) {
-      return;
-    }
-    if (watchIdRef.current !== null) {
-      navigator.geolocation.clearWatch(watchIdRef.current);
-    }
-    setState((prev) => ({ ...prev, loading: true }));
-    watchIdRef.current = navigator.geolocation.watchPosition(
-      (position) => {
-        setIsTracking(true);
-        handleSuccess(position);
-      },
-      handleError,
-      getGeolocationOptions()
-    );
-  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
-  const stopTracking = useCallback(() => {
-    if (watchIdRef.current === null) {
-      return;
-    }
-    navigator.geolocation.clearWatch(watchIdRef.current);
-    watchIdRef.current = null;
-    setIsTracking(false);
-  }, []);
-  useEffect(() => {
-    if (options?.mountBehavior === GeolocationMountBehavior.WATCH) {
-      startTracking();
-    } else if (options?.mountBehavior === GeolocationMountBehavior.GET) {
-      getCurrentPosition();
-    }
-    return () => {
-      if (watchIdRef.current !== null) {
-        navigator.geolocation.clearWatch(watchIdRef.current);
-        watchIdRef.current = null;
-      }
-    };
-  }, [options?.mountBehavior, getCurrentPosition, startTracking]);
-  return {
-    ...state,
-    getCurrentPosition,
-    startTracking,
-    stopTracking,
-    isTracking
-  };
-}
-export {
-  useGeolocation
-};

package/esm/hooks/useImpressionRef/index.js

@@ -1,232 +0,0 @@
-"use client";
-
-// src/hooks/useImpressionRef/useImpressionRef.ts
-import { useRef as useRef4 } from "react";
-
-// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
-
-// src/hooks/useDebounce/debounce.ts
-function debounce(func, debounceMs, { edges = ["leading", "trailing"] } = {}) {
-  let pendingThis = void 0;
-  let pendingArgs = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = () => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = void 0;
-      pendingArgs = null;
-    }
-  };
-  const onTimerEnd = () => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  };
-  let timeoutId = null;
-  const schedule = () => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
-    }, debounceMs);
-  };
-  const cancelTimer = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  const cancel = () => {
-    cancelTimer();
-    pendingThis = void 0;
-    pendingArgs = null;
-  };
-  const debounced = function(...args) {
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
-    }
-  };
-  debounced.cancel = cancel;
-  return debounced;
-}
-
-// src/hooks/usePreservedCallback/usePreservedCallback.ts
-import { useCallback, useEffect, useRef } from "react";
-function usePreservedCallback(callback) {
-  const callbackRef = useRef(callback);
-  useEffect(
-    function syncCallbackRef() {
-      callbackRef.current = callback;
-    },
-    [callback]
-  );
-  return useCallback((...args) => {
-    return callbackRef.current(...args);
-  }, []);
-}
-
-// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
-function useDebouncedCallback({
-  onChange,
-  timeThreshold,
-  leading = false,
-  trailing = true
-}) {
-  const handleChange = usePreservedCallback(onChange);
-  const ref = useRef2({ value: false, clearPreviousDebounce: () => {
-  } });
-  useEffect2(function clearDebouncedOnUnmount() {
-    const current = ref.current;
-    return () => {
-      current.clearPreviousDebounce();
-    };
-  }, []);
-  const edges = useMemo(() => {
-    const _edges = [];
-    if (leading) {
-      _edges.push("leading");
-    }
-    if (trailing) {
-      _edges.push("trailing");
-    }
-    return _edges;
-  }, [leading, trailing]);
-  return useCallback2(
-    (nextValue) => {
-      if (nextValue === ref.current.value) {
-        return;
-      }
-      const debounced = debounce(
-        () => {
-          handleChange(nextValue);
-          ref.current.value = nextValue;
-        },
-        timeThreshold,
-        { edges }
-      );
-      ref.current.clearPreviousDebounce();
-      debounced();
-      ref.current.clearPreviousDebounce = debounced.cancel;
-    },
-    [handleChange, timeThreshold, edges]
-  );
-}
-
-// src/hooks/useIntersectionObserver/useIntersectionObserver.ts
-import { useMemo as useMemo2 } from "react";
-
-// src/hooks/useRefEffect/useRefEffect.ts
-import { useCallback as useCallback3, useRef as useRef3 } from "react";
-function useRefEffect(callback, deps) {
-  const preservedCallback = usePreservedCallback(callback);
-  const cleanupCallbackRef = useRef3(() => {
-  });
-  const effect = useCallback3(
-    (element) => {
-      cleanupCallbackRef.current();
-      cleanupCallbackRef.current = () => {
-      };
-      if (element == null) {
-        return;
-      }
-      const cleanup = preservedCallback(element);
-      if (typeof cleanup === "function") {
-        cleanupCallbackRef.current = cleanup;
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [preservedCallback, ...deps]
-  );
-  return effect;
-}
-
-// src/hooks/useIntersectionObserver/useIntersectionObserver.ts
-function useIntersectionObserver(callback, options) {
-  const preservedCallback = usePreservedCallback(callback);
-  const observer = useMemo2(() => {
-    if (typeof IntersectionObserver === "undefined") {
-      return;
-    }
-    return new IntersectionObserver(([entry]) => {
-      preservedCallback(entry);
-    }, options);
-  }, [preservedCallback, options]);
-  return useRefEffect(
-    (element) => {
-      observer?.observe(element);
-      return () => {
-        observer?.unobserve(element);
-      };
-    },
-    [preservedCallback, options]
-  );
-}
-
-// src/hooks/useVisibilityEvent/useVisibilityEvent.ts
-import { useCallback as useCallback4, useEffect as useEffect3 } from "react";
-function useVisibilityEvent(callback, options = {}) {
-  const handleVisibilityChange = useCallback4(() => {
-    callback(document.visibilityState);
-  }, [callback]);
-  useEffect3(() => {
-    if (options?.immediate ?? false) {
-      handleVisibilityChange();
-    }
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    return () => {
-      document.removeEventListener("visibilitychange", handleVisibilityChange);
-    };
-  }, [handleVisibilityChange, options?.immediate]);
-}
-
-// src/hooks/useImpressionRef/useImpressionRef.ts
-function useImpressionRef({
-  onImpressionStart = () => {
-  },
-  onImpressionEnd = () => {
-  },
-  rootMargin,
-  areaThreshold = 0,
-  timeThreshold = 0
-}) {
-  const impressionStartHandler = usePreservedCallback(onImpressionStart);
-  const impressionEndHandler = usePreservedCallback(onImpressionEnd);
-  const isIntersectingRef = useRef4(false);
-  const impressionEventHandler = useDebouncedCallback({
-    timeThreshold,
-    onChange: (impressed) => {
-      (impressed ? impressionStartHandler : impressionEndHandler)();
-    },
-    leading: true
-  });
-  useVisibilityEvent((documentVisible) => {
-    if (!isIntersectingRef.current) {
-      return;
-    }
-    impressionEventHandler(documentVisible === "visible");
-  });
-  return useIntersectionObserver(
-    (entry) => {
-      if (document.visibilityState === "hidden") {
-        return;
-      }
-      const currentRatio = entry.intersectionRatio;
-      const isIntersecting = areaThreshold === 0 ? entry.isIntersecting : currentRatio >= areaThreshold;
-      isIntersectingRef.current = isIntersecting;
-      impressionEventHandler(isIntersecting);
-    },
-    { rootMargin, threshold: areaThreshold }
-  );
-}
-export {
-  useImpressionRef
-};

package/esm/hooks/useInputState/index.js

@@ -1,20 +0,0 @@
-"use client";
-
-// src/hooks/useInputState/useInputState.ts
-import { useCallback, useState } from "react";
-function useInputState(initialValue = "", transformValue = echo) {
-  const [value, setValue] = useState(initialValue);
-  const handleValueChange = useCallback(
-    ({ target: { value: value2 } }) => {
-      setValue(transformValue(value2));
-    },
-    [transformValue]
-  );
-  return [value, handleValueChange];
-}
-function echo(v) {
-  return v;
-}
-export {
-  useInputState
-};