react-simplikit 0.0.50 → 0.0.52

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,48 +0,0 @@
-"use client";
-
-// src/hooks/useInterval/useInterval.ts
-import { useEffect as useEffect2 } 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);
-  useEffect2(
-    function runImmediateCallback() {
-      if (immediate === true && enabled) {
-        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
-};

package/esm/hooks/useOutsideClickEffect/index.js

@@ -1,48 +0,0 @@
-"use client";
-
-// src/hooks/useOutsideClickEffect/useOutsideClickEffect.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/useOutsideClickEffect/useOutsideClickEffect.ts
-function useOutsideClickEffect(container, callback) {
-  const containers = useRef2([]);
-  const handleDocumentClick = usePreservedCallback(({ target }) => {
-    if (target === null) {
-      return;
-    }
-    if (containers.current.length === 0) {
-      return;
-    }
-    if (containers.current.some((x) => x.contains(target))) {
-      return;
-    }
-    callback();
-  });
-  useEffect2(() => {
-    containers.current = [container].flat(1).filter((item) => item != null);
-  }, [container]);
-  useEffect2(() => {
-    document.addEventListener("click", handleDocumentClick);
-    return () => {
-      document.removeEventListener("click", handleDocumentClick);
-    };
-  }, [handleDocumentClick]);
-}
-export {
-  useOutsideClickEffect
-};

package/esm/hooks/usePreservedCallback/index.js

@@ -1,19 +0,0 @@
-"use client";
-
-// 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);
-  }, []);
-}
-export {
-  usePreservedCallback
-};

package/esm/hooks/usePreservedReference/index.js

@@ -1,19 +0,0 @@
-"use client";
-
-// 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);
-}
-export {
-  usePreservedReference
-};

package/esm/hooks/usePrevious/index.js

@@ -1,22 +0,0 @@
-"use client";
-
-// src/hooks/usePrevious/usePrevious.ts
-import { useRef } from "react";
-var strictEquals = (prev, next) => prev === next;
-function usePrevious(state, compare = strictEquals) {
-  const prevRef = useRef(state);
-  const currentRef = useRef(state);
-  const isFirstRender = useRef(true);
-  if (isFirstRender.current) {
-    isFirstRender.current = false;
-    return prevRef.current;
-  }
-  if (!compare(currentRef.current, state)) {
-    prevRef.current = currentRef.current;
-    currentRef.current = state;
-  }
-  return prevRef.current;
-}
-export {
-  usePrevious
-};

package/esm/hooks/useRefEffect/index.js

@@ -1,46 +0,0 @@
-"use client";
-
-// src/hooks/useRefEffect/useRefEffect.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/useRefEffect/useRefEffect.ts
-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;
-}
-export {
-  useRefEffect
-};

package/esm/hooks/useSet/index.js

@@ -1,79 +0,0 @@
-"use client";
-
-// src/hooks/useSet/useSet.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/useSet/useSet.ts
-function useSet(initialState = /* @__PURE__ */ new Set()) {
-  const [set, setSet] = useState(() => new Set(initialState));
-  const preservedInitialState = usePreservedReference(initialState);
-  const add = usePreservedCallback((value) => {
-    setSet((prev) => {
-      const nextSet = new Set(prev);
-      nextSet.add(value);
-      return nextSet;
-    });
-  });
-  const remove = usePreservedCallback((value) => {
-    setSet((prev) => {
-      const nextSet = new Set(prev);
-      nextSet.delete(value);
-      return nextSet;
-    });
-  });
-  const toggle = usePreservedCallback((value) => {
-    setSet((prev) => {
-      const nextSet = new Set(prev);
-      if (nextSet.has(value)) {
-        nextSet.delete(value);
-      } else {
-        nextSet.add(value);
-      }
-      return nextSet;
-    });
-  });
-  const setAll = usePreservedCallback((values) => {
-    setSet(() => new Set(values));
-  });
-  const reset = usePreservedCallback(() => {
-    setSet(() => new Set(preservedInitialState));
-  });
-  const actions = useMemo2(
-    () => ({ add, remove, toggle, setAll, reset }),
-    [add, remove, toggle, setAll, reset]
-  );
-  return [set, actions];
-}
-export {
-  useSet
-};