@basic-ui/core 0.0.39 → 0.0.42

package/src/hooks/useGestureHandlers.ts

@@ -1,5 +1,11 @@
+import type {
+  MutableRefObject,
+  MouseEvent as ReactMouseEvent,
+  TouchEvent as ReactTouchEvent,
+} from 'react';
 import { useRef } from 'react';
-import type * as React from 'react';
+
+import { getOwnerDocument } from '../utils';
 
 export interface GestureHandlersState {
   target: null | EventTarget;
@@ -26,8 +32,8 @@ type SetStateFunc<S> = (
 ) => void;
 
 export interface GestureHandlersReturn {
-  onMouseDown: (e: React.MouseEvent<HTMLElement>) => void;
-  onTouchStart: (e: React.TouchEvent<HTMLElement>) => void;
+  onMouseDown: (e: ReactMouseEvent<HTMLElement>) => void;
+  onTouchStart: (e: ReactTouchEvent<HTMLElement>) => void;
 }
 
 export interface GestureHandlerOptions {
@@ -59,7 +65,7 @@ const VELOCITY_DEPR_FACTOR = FRAMERATE_CONST * 2;
 
 export function gestureHandlers(
   set: SetStateFunc<GestureHandlersState>,
-  containerRef?: React.MutableRefObject<HTMLElement | null>,
+  containerRef?: MutableRefObject<HTMLElement | null>,
   options: GestureHandlerOptions = {}
 ): GestureHandlersReturn {
   const { ensureTargetIsContainer = false, minTouchDelta = 0 } = options;
@@ -192,7 +198,7 @@ export function gestureHandlers(
     handleMove(e.touches.item(0) as any);
   }
 
-  function handleTouchStart(e: React.TouchEvent<HTMLElement>) {
+  function handleTouchStart(e: ReactTouchEvent<HTMLElement>) {
     // making sure we're not dragging the element when more than one finger press the screen
     const { touches } = e;
     if (touches.length > 1) {
@@ -207,21 +213,26 @@ export function gestureHandlers(
       return;
     }
 
-    window.addEventListener('touchmove', handleTouchMove, { passive: false });
-    window.addEventListener('touchend', handleTouchEnd);
-    window.addEventListener('touchcancel', handleTouchEnd);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const ownerDocument = getOwnerDocument(e.currentTarget)!;
+    const ownerWindow = ownerDocument.defaultView || window;
+    ownerWindow.addEventListener('touchmove', handleTouchMove, {
+      passive: false,
+    });
+    ownerWindow.addEventListener('touchend', handleTouchEnd);
+    ownerWindow.addEventListener('touchcancel', handleTouchEnd);
     handleDown(e.touches.item(0) as any);
   }
 
-  function handleTouchEnd() {
-    window.removeEventListener('touchmove', handleTouchMove);
-    window.removeEventListener('touchend', handleTouchEnd);
-    window.removeEventListener('touchcancel', handleTouchEnd);
+  function handleTouchEnd(this: Window) {
+    this.removeEventListener('touchmove', handleTouchMove);
+    this.removeEventListener('touchend', handleTouchEnd);
+    this.removeEventListener('touchcancel', handleTouchEnd);
     handleUp();
   }
 
   // Mouse handlers
-  function handleMouseDown(e: React.MouseEvent<HTMLElement>) {
+  function handleMouseDown(e: ReactMouseEvent<HTMLElement>) {
     if (
       ensureTargetIsContainer &&
       containerRef &&
@@ -230,16 +241,19 @@ export function gestureHandlers(
       return;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const ownerDocument = getOwnerDocument(e.currentTarget)!;
+    const ownerWindow = ownerDocument.defaultView || window;
     if (e.button === 0) {
-      window.addEventListener('mousemove', handleMove);
-      window.addEventListener('mouseup', handleMouseUp);
+      ownerWindow.addEventListener('mousemove', handleMove);
+      ownerWindow.addEventListener('mouseup', handleMouseUp);
       handleDown(e as any);
     }
   }
 
-  function handleMouseUp() {
-    window.removeEventListener('mousemove', handleMove);
-    window.removeEventListener('mouseup', handleMouseUp);
+  function handleMouseUp(this: Window) {
+    this.removeEventListener('mousemove', handleMove);
+    this.removeEventListener('mouseup', handleMouseUp);
     handleUp();
   }
   /* eslint-enable @typescript-eslint/no-use-before-define */
@@ -251,7 +265,7 @@ export function gestureHandlers(
 }
 
 export const useGestureHandlers = (
-  containerRef: React.MutableRefObject<HTMLElement | null> | undefined,
+  containerRef: MutableRefObject<HTMLElement | null> | undefined,
   onGesture: (e: GestureHandlersState) => void,
   options: GestureHandlerOptions = {}
 ) => {

package/src/hooks/useMeasure.ts

@@ -1,7 +1,7 @@
+import type { MutableRefObject } from 'react';
 import { useRef, useState, useEffect } from 'react';
-import ResizeObserver from 'resize-observer-polyfill';
 
-export function useMeasure(ref: React.MutableRefObject<HTMLElement | null>) {
+export function useMeasure(ref: MutableRefObject<HTMLElement | null>) {
   const ro = useRef<ResizeObserver | null>(null);
   const [bounds, setBounds] = useState({
     left: 0,

package/src/hooks/useOnClickOutside.ts

@@ -1,8 +1,8 @@
+import type { RefObject } from 'react';
 import { useEffect, useCallback } from 'react';
-import type * as React from 'react';
 
 export function useOnClickOutside(
-  ref: React.RefObject<any>,
+  ref: RefObject<any>,
   handler: (e: PointerEvent) => void,
   active = true
 ) {

package/src/hooks/useOnKeyDown.ts

@@ -1,18 +1,19 @@
 import { useEffect } from 'react';
 
 export function useOnKeyDown(
+  ownerWindow: Window,
   handler: (e: KeyboardEvent) => void,
   active = true
 ) {
   useEffect(() => {
     if (active) {
-      window.addEventListener('keydown', handler);
+      ownerWindow.addEventListener('keydown', handler);
 
       return () => {
-        window.removeEventListener('keydown', handler);
+        ownerWindow.removeEventListener('keydown', handler);
       };
     }
 
     return;
-  }, [active, handler]);
+  }, [ownerWindow, active, handler]);
 }

package/src/hooks/useRemoveBodyScroll.ts

@@ -1,29 +1,39 @@
+import type { RefObject } from 'react';
 import { useEffect } from 'react';
 
+import { getOwnerDocument } from '../utils';
+
 let scrollBodyCount = 0;
-export function useRemoveBodyScroll(open: boolean) {
+export function useRemoveBodyScroll(
+  open: boolean,
+  elementRef: RefObject<HTMLElement | null>
+) {
   useEffect(() => {
-    if (open) {
+    if (open && elementRef.current) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const ownerDocument = getOwnerDocument(elementRef.current)!;
+      const ownerWindow = ownerDocument.defaultView || window;
       scrollBodyCount += 1;
 
       // calculate scrollbar width if mounting the first scroll lock
       let scrollBarWidth = 0;
       if (scrollBodyCount === 1) {
-        scrollBarWidth = window.innerWidth - document.body.clientWidth;
+        scrollBarWidth =
+          ownerWindow.innerWidth - ownerDocument.body.clientWidth;
       }
 
-      document.body.style.overflow = 'hidden';
+      ownerDocument.body.style.overflow = 'hidden';
       if (scrollBarWidth > 0) {
-        document.body.style.marginRight = `${scrollBarWidth}px`;
+        ownerDocument.body.style.marginRight = `${scrollBarWidth}px`;
       }
 
       return () => {
         scrollBodyCount -= 1;
         if (scrollBodyCount === 0) {
-          document.body.style.overflow = '';
-          document.body.style.marginRight = '';
+          ownerDocument.body.style.overflow = '';
+          ownerDocument.body.style.marginRight = '';
         }
       };
     }
-  }, [open]);
+  }, [elementRef, open]);
 }

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './Modal';
 export * from './Popper';
 export * from './Portal';
 export * from './RadioButton';
+export * from './Slider';
 export * from './Spinner';
 export * from './Tabs';
 export * from './Tooltip';

package/src/utils/{assignRef.ts → assign-ref.ts}

@@ -1,7 +1,7 @@
-import type { LegacyRef, MutableRefObject, Ref, RefCallback } from 'react';
+import type { MutableRefObject, RefCallback } from 'react';
 
 export function assignRef<T>(
-  ref: LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined,
+  ref: MutableRefObject<T> | RefCallback<T> | null | undefined,
   value: T
 ) {
   if (ref == null) return;
@@ -9,7 +9,7 @@ export function assignRef<T>(
     ref(value);
   } else {
     try {
-      (ref as MutableRefObject<T>).current = value;
+      ref.current = value;
     } catch (error) {
       throw new Error(`Cannot assign value "${value}" to ref "${ref}"`);
     }
@@ -17,7 +17,7 @@ export function assignRef<T>(
 }
 
 export function assignMultipleRefs<T>(
-  ...refs: (LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined)[]
+  ...refs: (MutableRefObject<T> | RefCallback<T> | null | undefined)[]
 ): RefCallback<T> {
   return (node: T | null) => {
     refs.forEach((ref) => {

package/src/utils/can-use-dom.ts

@@ -0,0 +1,7 @@
+export function canUseDOM() {
+  return !!(
+    typeof window !== 'undefined' &&
+    window.document &&
+    window.document.createElement
+  );
+}

package/src/utils/context.tsx

@@ -0,0 +1,48 @@
+import type { FC, PropsWithChildren } from 'react';
+import {
+  useMemo,
+  createContext as ReactCreateContext,
+  useContext as useReactContext,
+} from 'react';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type ContextProvider<T> = FC<PropsWithChildren<T>>;
+
+export function createContext<ContextValueType extends object | null>(
+  rootName: string,
+  defaultContext?: ContextValueType
+): [
+  ContextProvider<ContextValueType>,
+  (childName: string) => ContextValueType
+] {
+  const Ctx = ReactCreateContext<ContextValueType | undefined>(defaultContext);
+
+  function Provider(props: PropsWithChildren<ContextValueType>) {
+    const { children, ...context } = props;
+    const value = useMemo(
+      () => context,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      Object.values(context)
+    ) as ContextValueType;
+    return <Ctx.Provider value={value}>{children}</Ctx.Provider>;
+  }
+
+  function useContext(childName: string) {
+    const context = useReactContext(Ctx);
+    if (context) {
+      return context;
+    }
+    if (defaultContext) {
+      return defaultContext;
+    }
+    throw Error(
+      `${childName} must be rendered inside of a ${rootName} component.`
+    );
+  }
+
+  Ctx.displayName = `${rootName}Context`;
+  Provider.displayName = `${rootName}Provider`;
+
+  return [Provider, useContext];
+}

package/src/utils/index.ts

@@ -1,4 +1,10 @@
-export * from './assignRef';
-export * from './wrapEvent';
-export * from './getCircularIndex';
-export * from './rubberBandClamp';
+export * from './assign-ref';
+export * from './can-use-dom';
+export * from './context';
+export * from './get-circular-index';
+export * from './is-right-click';
+export * from './owner-document';
+export * from './polymorphic';
+export * from './rubber-band-clamp';
+export * from './use-stable-callback';
+export * from './wrap-event';

package/src/utils/is-right-click.ts

@@ -0,0 +1,14 @@
+/**
+ * Detects right clicks
+ *
+ * @param nativeEvent
+ */
+export function isRightClick(
+  nativeEvent: MouseEvent | PointerEvent | TouchEvent
+) {
+  return 'which' in nativeEvent
+    ? nativeEvent.which === 3
+    : 'button' in nativeEvent
+    ? (nativeEvent as any).button === 2
+    : false;
+}

package/src/utils/owner-document.ts

@@ -0,0 +1,13 @@
+import { canUseDOM } from './can-use-dom';
+
+/**
+ * Get an element's owner document. Useful when components are used in iframes
+ * or other environments like dev tools.
+ *
+ * @param element
+ */
+export function getOwnerDocument<T extends Element>(
+  element: T | null | undefined
+) {
+  return canUseDOM() ? (element ? element.ownerDocument : document) : null;
+}

package/src/utils/polymorphic.ts

@@ -0,0 +1,72 @@
+/* eslint-disable @typescript-eslint/ban-types */
+// adapted from https://github.com/radix-ui/primitives/blob/2f139a832ba0cdfd445c937ebf63c2e79e0ef7ed/packages/react/polymorphic/src/polymorphic.ts
+// Would have liked to use it directly instead of copying but they are
+// (rightfully) treating it as an internal utility, so copy/paste it is to
+// prevent any needless churn if they make breaking changes. Big thanks to Jenna
+// for the heavy lifting! https://github.com/jjenzz
+
+import type * as React from 'react';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Merge<P1 = {}, P2 = {}> = Omit<P1, keyof P2> & P2;
+
+/**
+ * Infers the OwnProps if E is a ForwardRefExoticComponentWithAs
+ */
+export type OwnProps<E> = E extends ForwardRefComponent<any, infer P> ? P : {};
+
+/**
+ * Infers the JSX.IntrinsicElement if E is a ForwardRefExoticComponentWithAs
+ */
+export type IntrinsicElement<E> = E extends ForwardRefComponent<infer I, any>
+  ? I
+  : never;
+
+type ForwardRefExoticComponent<E, OwnProps> = React.ForwardRefExoticComponent<
+  Merge<
+    E extends React.ElementType ? React.ComponentPropsWithRef<E> : never,
+    OwnProps & { as?: E }
+  >
+>;
+
+export interface ForwardRefComponent<
+  IntrinsicElementString,
+  OwnProps = {}
+  /*
+   * Extends original type to ensure built in React types play nice with
+   * polymorphic components still e.g. `React.ElementRef` etc.
+   */
+> extends ForwardRefExoticComponent<IntrinsicElementString, OwnProps> {
+  /*
+   * When `as` prop is passed, use this overload. Merges original own props
+   * (without DOM props) and the inferred props from `as` element with the own
+   * props taking precendence.
+   *
+   * We explicitly avoid `React.ElementType` and manually narrow the prop types
+   * so that events are typed when using JSX.IntrinsicElements.
+   */
+  <As = IntrinsicElementString>(
+    props: As extends ''
+      ? { as: keyof JSX.IntrinsicElements }
+      : As extends React.ComponentType<infer P>
+      ? Merge<P, OwnProps & { as: As }>
+      : As extends keyof JSX.IntrinsicElements
+      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As }>
+      : never
+  ): React.ReactElement | null;
+}
+
+export interface MemoComponent<IntrinsicElementString, OwnProps = {}>
+  extends React.MemoExoticComponent<
+    ForwardRefComponent<IntrinsicElementString, OwnProps>
+  > {
+  <As = IntrinsicElementString>(
+    props: As extends ''
+      ? { as: keyof JSX.IntrinsicElements }
+      : As extends React.ComponentType<infer P>
+      ? Merge<P, OwnProps & { as: As }>
+      : As extends keyof JSX.IntrinsicElements
+      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As }>
+      : never
+  ): React.ReactElement | null;
+}

package/src/utils/use-stable-callback.ts

@@ -0,0 +1,58 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import { useRef, useEffect, useCallback, useLayoutEffect } from 'react';
+import type * as React from 'react';
+
+const useEnhancedEffect =
+  typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when
+ * passed as a dependency.
+ */
+function createStableCallbackHook<T extends (...args: any[]) => any>(
+  useEffectHook: (
+    effect: React.EffectCallback,
+    deps?: React.DependencyList | undefined
+  ) => void,
+  callback: T | null | undefined
+): T {
+  const callbackRef = useRef(callback);
+  useEffectHook(() => {
+    callbackRef.current = callback;
+  });
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useCallback(
+    ((...args) => {
+      callbackRef.current && callbackRef.current(...args);
+    }) as T,
+    []
+  );
+}
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when passed
+ * as a dependency.
+ */
+export function useStableCallback<T extends (...args: any[]) => any>(
+  callback: T | null | undefined
+): T {
+  return createStableCallbackHook(useEffect, callback);
+}
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when passed
+ * as a dependency.
+ *
+ * Use this over `useStableCallback` when you want the callback to be cached in
+ * `useLayoutEffect` instead of `useEffect` to deal with timing issues only when
+ * needed.
+ */
+export function useStableLayoutCallback<T extends (...args: any[]) => any>(
+  callback: T | null | undefined
+): T {
+  return createStableCallbackHook(useEnhancedEffect, callback);
+}

package/src/utils/wrap-event.ts

@@ -0,0 +1,22 @@
+import type { SyntheticEvent } from 'react';
+
+export type CustomEventHandler<
+  E extends SyntheticEvent<any> | Event,
+  H extends unknown[]
+> = (e: E, ...args: H) => void;
+
+export function wrapEvent<
+  EventType extends SyntheticEvent<any> | Event,
+  H extends unknown[]
+>(
+  theirHandler: CustomEventHandler<EventType, H> | undefined,
+  ourHandler: CustomEventHandler<EventType, H>
+): CustomEventHandler<EventType, H> {
+  return (event: EventType, ...otherArgs: H) => {
+    const ret = theirHandler && theirHandler(event, ...otherArgs);
+    if (!event.defaultPrevented) {
+      return ourHandler(event, ...otherArgs);
+    }
+    return ret;
+  };
+}

package/build/esm/utils/assignRef.d.ts

@@ -1,3 +0,0 @@
-import type { LegacyRef, MutableRefObject, Ref, RefCallback } from 'react';
-export declare function assignRef<T>(ref: LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined, value: T): void;
-export declare function assignMultipleRefs<T>(...refs: (LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined)[]): RefCallback<T>;

package/build/esm/utils/assignRef.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/assignRef.ts"],"names":["assignRef","ref","value","current","error","Error","assignMultipleRefs","refs","node","forEach"],"mappings":"AAEA,OAAO,SAASA,SAAT,CACLC,GADK,EAELC,KAFK,EAGL;AACA,MAAID,GAAG,IAAI,IAAX,EAAiB;;AACjB,MAAI,OAAOA,GAAP,KAAe,UAAnB,EAA+B;AAC7BA,IAAAA,GAAG,CAACC,KAAD,CAAH;AACD,GAFD,MAEO;AACL,QAAI;AACDD,MAAAA,GAAD,CAA6BE,OAA7B,GAAuCD,KAAvC;AACD,KAFD,CAEE,OAAOE,KAAP,EAAc;AACd,YAAM,IAAIC,KAAJ,iCAAkCH,KAAlC,yBAAoDD,GAApD,QAAN;AACD;AACF;AACF;AAED,OAAO,SAASK,kBAAT,GAEW;AAAA,oCADbC,IACa;AADbA,IAAAA,IACa;AAAA;;AAChB,SAAO,UAACC,IAAD,EAAoB;AACzBD,IAAAA,IAAI,CAACE,OAAL,CAAa,UAACR,GAAD,EAAS;AACpBD,MAAAA,SAAS,CAACC,GAAD,EAAMO,IAAN,CAAT;AACD,KAFD;AAGD,GAJD;AAKD","sourcesContent":["import type { LegacyRef, MutableRefObject, Ref, RefCallback } from 'react';\n\nexport function assignRef<T>(\n  ref: LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined,\n  value: T\n) {\n  if (ref == null) return;\n  if (typeof ref === 'function') {\n    ref(value);\n  } else {\n    try {\n      (ref as MutableRefObject<T>).current = value;\n    } catch (error) {\n      throw new Error(`Cannot assign value \"${value}\" to ref \"${ref}\"`);\n    }\n  }\n}\n\nexport function assignMultipleRefs<T>(\n  ...refs: (LegacyRef<T> | MutableRefObject<T> | Ref<T> | null | undefined)[]\n): RefCallback<T> {\n  return (node: T | null) => {\n    refs.forEach((ref) => {\n      assignRef(ref, node);\n    });\n  };\n}\n"],"file":"assignRef.js"}

package/build/esm/utils/createSubscription.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/createSubscription.ts"],"names":["createSubscription","subscriptions","subscribe","fn","push","splice","indexOf","notify","forEach"],"mappings":"AAAA,OAAO,SAASA,kBAAT,GAA8B;AACnC,MAAMC,aAA6B,GAAG,EAAtC;;AAEA,WAASC,SAAT,CAAmBC,EAAnB,EAAmC;AACjCF,IAAAA,aAAa,CAACG,IAAd,CAAmBD,EAAnB;AACA,WAAO,YAAM;AACXF,MAAAA,aAAa,CAACI,MAAd,CAAqBJ,aAAa,CAACK,OAAd,CAAsBH,EAAtB,CAArB,EAAgD,CAAhD;AACD,KAFD;AAGD;;AAED,WAASI,MAAT,GAAkB;AAChBN,IAAAA,aAAa,CAACO,OAAd,CAAsB,UAACL,EAAD;AAAA,aAAQA,EAAE,EAAV;AAAA,KAAtB;AACD;;AAED,SAAO;AAAED,IAAAA,SAAS,EAATA,SAAF;AAAaK,IAAAA,MAAM,EAANA;AAAb,GAAP;AACD","sourcesContent":["export function createSubscription() {\n  const subscriptions: (() => void)[] = [];\n\n  function subscribe(fn: () => void) {\n    subscriptions.push(fn);\n    return () => {\n      subscriptions.splice(subscriptions.indexOf(fn), 1);\n    };\n  }\n\n  function notify() {\n    subscriptions.forEach((fn) => fn());\n  }\n\n  return { subscribe, notify };\n}\n"],"file":"createSubscription.js"}

package/build/esm/utils/getCircularIndex.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/getCircularIndex.ts"],"names":["getCircularIndex","index","maxLength"],"mappings":"AAAA,OAAO,SAASA,gBAAT,CAA0BC,KAA1B,EAAyCC,SAAzC,EAA4D;AACjE,MAAIA,SAAS,GAAG,CAAhB,EAAmB;AACjB,WAAO,IAAP;AACD;;AAED,SAAO,CAAED,KAAK,GAAGC,SAAT,GAAsBA,SAAvB,IAAoCA,SAA3C;AACD","sourcesContent":["export function getCircularIndex(index: number, maxLength: number) {\n  if (maxLength < 0) {\n    return null;\n  }\n\n  return ((index % maxLength) + maxLength) % maxLength;\n}\n"],"file":"getCircularIndex.js"}

package/build/esm/utils/rubberBandClamp.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/rubberBandClamp.ts"],"names":["rubberBand","distance","dimension","constant","rubberBandClamp","min","max","delta"],"mappings":"AAAA;AACA;AACA,OAAO,SAASA,UAAT,CACLC,QADK,EAELC,SAFK,EAIL;AAAA,MADAC,QACA,uEADW,IACX;AACA,SAAQF,QAAQ,GAAGC,SAAX,GAAuBC,QAAxB,IAAqCD,SAAS,GAAGC,QAAQ,GAAGF,QAA5D,CAAP;AACD;AAED,OAAO,SAASG,eAAT,CACLC,GADK,EAELC,GAFK,EAGLC,KAHK,EAKL;AAAA,MADAJ,QACA,uEADW,IACX;;AACA,MAAII,KAAK,GAAGF,GAAZ,EAAiB;AACf,WAAO,CAACL,UAAU,CAACK,GAAG,GAAGE,KAAP,EAAcD,GAAG,GAAGD,GAApB,EAAyBF,QAAzB,CAAX,GAAgDE,GAAvD;AACD;;AACD,MAAIE,KAAK,GAAGD,GAAZ,EAAiB;AACf,WAAON,UAAU,CAACO,KAAK,GAAGD,GAAT,EAAcA,GAAG,GAAGD,GAApB,EAAyBF,QAAzB,CAAV,GAA+CG,GAAtD;AACD;;AAED,SAAOC,KAAP;AACD","sourcesContent":["// https://twitter.com/chpwn/status/285540192096497664\n// iOS constant = 0.55\nexport function rubberBand(\n  distance: number,\n  dimension: number,\n  constant = 0.15\n) {\n  return (distance * dimension * constant) / (dimension + constant * distance);\n}\n\nexport function rubberBandClamp(\n  min: number,\n  max: number,\n  delta: number,\n  constant = 0.15\n) {\n  if (delta < min) {\n    return -rubberBand(min - delta, max - min, constant) + min;\n  }\n  if (delta > max) {\n    return rubberBand(delta - max, max - min, constant) + max;\n  }\n\n  return delta;\n}\n"],"file":"rubberBandClamp.js"}

package/build/esm/utils/wrapEvent.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="react" />
-export declare type CustomEventHandler<E extends React.SyntheticEvent<any>, H extends unknown[]> = (e: E, ...args: H) => void;
-export declare function wrapEvent<E extends React.SyntheticEvent<any>, H extends unknown[]>(theirHandler: CustomEventHandler<E, H> | undefined, ourHandler: CustomEventHandler<E, H>): CustomEventHandler<E, H>;

package/build/esm/utils/wrapEvent.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/wrapEvent.ts"],"names":["wrapEvent","theirHandler","ourHandler","event","otherArgs","ret","defaultPrevented"],"mappings":"AAKA,OAAO,SAASA,SAAT,CAILC,YAJK,EAKLC,UALK,EAMqB;AAC1B,SAAO,UAACC,KAAD,EAA+B;AAAA,sCAAjBC,SAAiB;AAAjBA,MAAAA,SAAiB;AAAA;;AACpC,QAAMC,GAAG,GAAGJ,YAAY,IAAIA,YAAY,MAAZ,UAAaE,KAAb,SAAuBC,SAAvB,EAA5B;;AACA,QAAI,CAACD,KAAK,CAACG,gBAAX,EAA6B;AAC3B,aAAOJ,UAAU,MAAV,UAAWC,KAAX,SAAqBC,SAArB,EAAP;AACD;;AACD,WAAOC,GAAP;AACD,GAND;AAOD","sourcesContent":["export type CustomEventHandler<\n  E extends React.SyntheticEvent<any>,\n  H extends unknown[]\n> = (e: E, ...args: H) => void;\n\nexport function wrapEvent<\n  E extends React.SyntheticEvent<any>,\n  H extends unknown[]\n>(\n  theirHandler: CustomEventHandler<E, H> | undefined,\n  ourHandler: CustomEventHandler<E, H>\n): CustomEventHandler<E, H> {\n  return (event: E, ...otherArgs: H) => {\n    const ret = theirHandler && theirHandler(event, ...otherArgs);\n    if (!event.defaultPrevented) {\n      return ourHandler(event, ...otherArgs);\n    }\n    return ret;\n  };\n}\n"],"file":"wrapEvent.js"}