react-simplikit 0.0.51 → 0.0.52

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
-};

package/esm/hooks/useIntersectionObserver/index.js

@@ -1,69 +0,0 @@
-"use client";
-
-// src/hooks/useIntersectionObserver/useIntersectionObserver.ts
-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/useRefEffect/useRefEffect.ts
-import { useCallback as useCallback2, useRef as useRef2 } from "react";
-function useRefEffect(callback, deps) {
-  const preservedCallback = usePreservedCallback(callback);
-  const cleanupCallbackRef = useRef2(() => {
-  });
-  const effect = useCallback2(
-    (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 = useMemo(() => {
-    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]
-  );
-}
-export {
-  useIntersectionObserver
-};

package/esm/hooks/useInterval/index.js

@@ -1,58 +0,0 @@
-"use client";
-
-// src/hooks/useInterval/useInterval.ts
-import { 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/useInterval/useInterval.ts
-function useInterval(callback, options) {
-  const delay = typeof options === "number" ? options : options.delay;
-  const immediate = typeof options === "number" ? false : options.immediate;
-  const enabled = typeof options === "number" ? true : options.enabled ?? true;
-  const preservedCallback = usePreservedCallback(callback);
-  const immediateCalledRef = useRef2(false);
-  useEffect2(
-    function runImmediateCallback() {
-      if (immediate !== true) {
-        immediateCalledRef.current = false;
-        return;
-      }
-      if (!enabled) {
-        return;
-      }
-      if (immediateCalledRef.current) {
-        return;
-      }
-      immediateCalledRef.current = true;
-      preservedCallback();
-    },
-    [immediate, preservedCallback, enabled]
-  );
-  useEffect2(
-    function startInterval() {
-      if (!enabled) {
-        return;
-      }
-      const id = setInterval(preservedCallback, delay);
-      return () => clearInterval(id);
-    },
-    [delay, preservedCallback, enabled]
-  );
-}
-export {
-  useInterval
-};

package/esm/hooks/useIsClient/index.js

@@ -1,14 +0,0 @@
-"use client";
-
-// src/hooks/useIsClient/useIsClient.ts
-import { useEffect, useState } from "react";
-function useIsClient() {
-  const [isClient, setIsClient] = useState(false);
-  useEffect(function syncClientState() {
-    setIsClient(true);
-  }, []);
-  return isClient;
-}
-export {
-  useIsClient
-};

package/esm/hooks/useIsomorphicLayoutEffect/index.js

@@ -1,9 +0,0 @@
-"use client";
-
-// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
-import { useEffect, useLayoutEffect } from "react";
-var isServer = typeof window === "undefined";
-var useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
-export {
-  useIsomorphicLayoutEffect
-};

package/esm/hooks/useList/index.js

@@ -1,78 +0,0 @@
-"use client";
-
-// src/hooks/useList/useList.ts
-import { useMemo as useMemo2, useState } 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/usePreservedReference/usePreservedReference.ts
-import { useMemo, useRef as useRef2 } from "react";
-function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
-  const ref = useRef2(value);
-  return useMemo(() => {
-    if (!areValuesEqual(ref.current, value)) {
-      ref.current = value;
-    }
-    return ref.current;
-  }, [areValuesEqual, value]);
-}
-function areDeeplyEqual(x, y) {
-  return JSON.stringify(x) === JSON.stringify(y);
-}
-
-// src/hooks/useList/useList.ts
-function useList(initialState = []) {
-  const [list, setList] = useState(initialState);
-  const preservedInitialState = usePreservedReference(initialState);
-  const push = usePreservedCallback((value) => {
-    setList((prev) => [...prev, value]);
-  });
-  const insertAt = usePreservedCallback((index, value) => {
-    setList((prev) => {
-      const next = [...prev];
-      next.splice(index, 0, value);
-      return next;
-    });
-  });
-  const updateAt = usePreservedCallback((index, value) => {
-    setList((prev) => {
-      const next = [...prev];
-      next[index] = value;
-      return next;
-    });
-  });
-  const removeAt = usePreservedCallback((index) => {
-    setList((prev) => {
-      const next = [...prev];
-      next.splice(index, 1);
-      return next;
-    });
-  });
-  const setAll = usePreservedCallback((values) => {
-    setList(values);
-  });
-  const reset = usePreservedCallback(() => {
-    setList(preservedInitialState);
-  });
-  const actions = useMemo2(
-    () => ({ push, insertAt, updateAt, removeAt, setAll, reset }),
-    [push, insertAt, updateAt, removeAt, setAll, reset]
-  );
-  return [list, actions];
-}
-export {
-  useList
-};

package/esm/hooks/useLoading/index.js

@@ -1,39 +0,0 @@
-"use client";
-
-// src/hooks/useLoading/useLoading.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-function useLoading() {
-  const [loading, setLoading] = useState(false);
-  const ref = useIsMountedRef();
-  const startTransition = useCallback(
-    async (promise) => {
-      try {
-        setLoading(true);
-        const data = await promise;
-        return data;
-      } finally {
-        if (ref.isMounted) {
-          setLoading(false);
-        }
-      }
-    },
-    [ref.isMounted]
-  );
-  return useMemo(() => [loading, startTransition], [loading, startTransition]);
-}
-function useIsMountedRef() {
-  const ref = useRef({ isMounted: true }).current;
-  useEffect(
-    function trackMountedState() {
-      ref.isMounted = true;
-      return () => {
-        ref.isMounted = false;
-      };
-    },
-    [ref]
-  );
-  return ref;
-}
-export {
-  useLoading
-};

package/esm/hooks/useLongPress/index.js

@@ -1,101 +0,0 @@
-"use client";
-
-// src/hooks/useLongPress/useLongPress.ts
-import { useCallback as useCallback2, 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/useLongPress/useLongPress.ts
-function useLongPress(onLongPress, { delay = 500, moveThreshold, onClick, onLongPressEnd } = {}) {
-  const timeoutRef = useRef2(null);
-  const isLongPressActiveRef = useRef2(false);
-  const initialPositionRef = useRef2({ x: 0, y: 0 });
-  const preservedOnLongPress = usePreservedCallback(onLongPress);
-  const preservedOnClick = usePreservedCallback(onClick || (() => {
-  }));
-  const preservedOnLongPressEnd = usePreservedCallback(onLongPressEnd || (() => {
-  }));
-  const hasThreshold = moveThreshold?.x !== void 0 || moveThreshold?.y !== void 0;
-  const getClientPosition = useCallback2((event) => {
-    if ("touches" in event.nativeEvent) {
-      const touch = event.nativeEvent.touches[0];
-      return { x: touch.clientX, y: touch.clientY };
-    }
-    return {
-      x: event.nativeEvent.clientX,
-      y: event.nativeEvent.clientY
-    };
-  }, []);
-  const isMovedBeyondThreshold = useCallback2(
-    (event) => {
-      const { x, y } = getClientPosition(event);
-      const deltaX = Math.abs(x - initialPositionRef.current.x);
-      const deltaY = Math.abs(y - initialPositionRef.current.y);
-      return moveThreshold?.x !== void 0 && deltaX > moveThreshold.x || moveThreshold?.y !== void 0 && deltaY > moveThreshold.y;
-    },
-    [getClientPosition, moveThreshold]
-  );
-  const cancelLongPress = useCallback2(() => {
-    if (timeoutRef.current !== null) {
-      window.clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-  }, []);
-  const handlePressStart = useCallback2(
-    (event) => {
-      cancelLongPress();
-      const position = getClientPosition(event);
-      initialPositionRef.current = position;
-      isLongPressActiveRef.current = false;
-      timeoutRef.current = window.setTimeout(() => {
-        isLongPressActiveRef.current = true;
-        preservedOnLongPress(event);
-      }, delay);
-    },
-    [cancelLongPress, delay, getClientPosition, preservedOnLongPress]
-  );
-  const handlePressEnd = useCallback2(
-    (event) => {
-      if (isLongPressActiveRef.current) {
-        preservedOnLongPressEnd(event);
-      } else if (timeoutRef.current !== null) {
-        preservedOnClick(event);
-      }
-      cancelLongPress();
-      isLongPressActiveRef.current = false;
-    },
-    [cancelLongPress, preservedOnClick, preservedOnLongPressEnd]
-  );
-  const handlePressMove = useCallback2(
-    (event) => {
-      if (timeoutRef.current !== null && isMovedBeyondThreshold(event)) {
-        cancelLongPress();
-      }
-    },
-    [cancelLongPress, isMovedBeyondThreshold]
-  );
-  return {
-    onMouseDown: handlePressStart,
-    onMouseUp: handlePressEnd,
-    onMouseLeave: cancelLongPress,
-    onTouchStart: handlePressStart,
-    onTouchEnd: handlePressEnd,
-    ...hasThreshold ? { onTouchMove: handlePressMove, onMouseMove: handlePressMove } : {}
-  };
-}
-export {
-  useLongPress
-};

package/esm/hooks/useMap/index.js

@@ -1,52 +0,0 @@
-"use client";
-
-// src/hooks/useMap/useMap.ts
-import { useCallback, useMemo as useMemo2, useState } from "react";
-
-// src/hooks/usePreservedReference/usePreservedReference.ts
-import { useMemo, useRef } from "react";
-function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
-  const ref = useRef(value);
-  return useMemo(() => {
-    if (!areValuesEqual(ref.current, value)) {
-      ref.current = value;
-    }
-    return ref.current;
-  }, [areValuesEqual, value]);
-}
-function areDeeplyEqual(x, y) {
-  return JSON.stringify(x) === JSON.stringify(y);
-}
-
-// src/hooks/useMap/useMap.ts
-function useMap(initialState = /* @__PURE__ */ new Map()) {
-  const [map, setMap] = useState(() => new Map(initialState));
-  const preservedInitialState = usePreservedReference(initialState);
-  const set = useCallback((key, value) => {
-    setMap((prev) => {
-      const nextMap = new Map(prev);
-      nextMap.set(key, value);
-      return nextMap;
-    });
-  }, []);
-  const setAll = useCallback((entries) => {
-    setMap(() => new Map(entries));
-  }, []);
-  const remove = useCallback((key) => {
-    setMap((prev) => {
-      const nextMap = new Map(prev);
-      nextMap.delete(key);
-      return nextMap;
-    });
-  }, []);
-  const reset = useCallback(() => {
-    setMap(() => new Map(preservedInitialState));
-  }, [preservedInitialState]);
-  const actions = useMemo2(() => {
-    return { set, setAll, remove, reset };
-  }, [set, setAll, remove, reset]);
-  return [map, actions];
-}
-export {
-  useMap
-};