react-panel-layout 0.6.0 → 0.6.1

package/dist/useDocumentPointerEvents-DXxw3qWj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocumentPointerEvents-DXxw3qWj.js","sources":["../src/hooks/useEffectEvent.ts","../src/hooks/useDocumentPointerEvents.ts"],"sourcesContent":["/**\n * @file useEffectEvent hook - Stable event handler for Effects\n *\n * This hook allows you to extract event handlers from Effects without causing them to re-run.\n * The returned function is stable and can be safely used in effect dependencies.\n *\n * @see https://react.dev/learn/separating-events-from-effects#declaring-an-effect-event\n */\nimport * as React from \"react\";\n\n/**\n * Extract event handlers from Effects to avoid unnecessary re-runs\n *\n * @example\n * ```tsx\n * function Component({ onEvent }) {\n *   const onEventHandler = useEffectEvent(onEvent);\n *\n *   React.useEffect(() => {\n *     // onEventHandler is stable, but always calls the latest onEvent\n *     const cleanup = subscribe(onEventHandler);\n *     return cleanup;\n *   }, []); // No need to include onEvent in dependencies\n * }\n * ```\n */\nexport function useEffectEvent<Args extends unknown[], Return>(\n  fn: ((...args: Args) => Return) | undefined,\n): (...args: Args) => Return | undefined {\n  const ref = React.useRef<typeof fn>(fn);\n  ref.current = fn;\n\n  return React.useCallback((...args: Args): Return | undefined => {\n    const currentFn = ref.current;\n    if (currentFn) {\n      return currentFn(...args);\n    }\n    return undefined;\n  }, []);\n}\n","/**\n * @file Hooks for managing document-level pointer events with proper cleanup\n */\nimport * as React from \"react\";\nimport { useEffectEvent } from \"./useEffectEvent\";\n\nexport type UseDocumentPointerEventsOptions = {\n  onMove?: (e: PointerEvent) => void;\n  onUp?: (e: PointerEvent) => void;\n  onCancel?: (e: PointerEvent) => void;\n};\n\n/**\n * Custom hook for managing document-level pointer events with proper cleanup\n * This pattern is commonly used for drag operations that need to continue\n * even when the pointer moves outside the original element\n */\nexport function useDocumentPointerEvents(enabled: boolean, handlers: UseDocumentPointerEventsOptions) {\n  const handleMoveEvent = useEffectEvent(handlers.onMove);\n  const handleUpEvent = useEffectEvent(handlers.onUp);\n  const handleCancelEvent = useEffectEvent(handlers.onCancel);\n\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    if (handlers.onMove) {\n      document.addEventListener(\"pointermove\", handleMoveEvent, { passive: false });\n    }\n    if (handlers.onUp) {\n      document.addEventListener(\"pointerup\", handleUpEvent);\n    }\n    if (handlers.onCancel) {\n      document.addEventListener(\"pointercancel\", handleCancelEvent);\n    }\n\n    // Cleanup function\n    return () => {\n      if (handlers.onMove) {\n        document.removeEventListener(\"pointermove\", handleMoveEvent);\n      }\n      if (handlers.onUp) {\n        document.removeEventListener(\"pointerup\", handleUpEvent);\n      }\n      if (handlers.onCancel) {\n        document.removeEventListener(\"pointercancel\", handleCancelEvent);\n      }\n    };\n  }, [enabled, handlers.onMove, handlers.onUp, handlers.onCancel, handleMoveEvent, handleUpEvent, handleCancelEvent]);\n}\n\n/**\n * Hook for capturing pointer during drag operations\n * This ensures that pointer events are delivered to the capturing element\n * even when the pointer moves outside its boundaries\n */\nexport function usePointerCapture(elementRef: React.RefObject<HTMLElement | null>, enabled: boolean, pointerId?: number) {\n  React.useEffect(() => {\n    const element = elementRef.current;\n    if (!enabled || !element || pointerId === undefined) {\n      return;\n    }\n\n    // Capture pointer\n    element.setPointerCapture(pointerId);\n\n    // Release capture on cleanup\n    return () => {\n      if (element.hasPointerCapture && element.hasPointerCapture(pointerId)) {\n        element.releasePointerCapture(pointerId);\n      }\n    };\n  }, [elementRef, enabled, pointerId]);\n}\n\n/**\n * Hook for preventing default pointer events during operations\n * Useful for preventing text selection, context menus, etc. during drag operations\n */\nexport function usePreventPointerDefaults(\n  elementRef: React.RefObject<HTMLElement | null>,\n  enabled: boolean,\n  events: string[] = [\"pointerdown\", \"pointermove\", \"pointerup\"],\n) {\n  React.useEffect(() => {\n    const element = elementRef.current;\n    if (!enabled || !element) {\n      return;\n    }\n\n    const preventDefault = (e: Event) => {\n      e.preventDefault();\n    };\n\n    // Add listeners\n    events.forEach((eventType) => {\n      element.addEventListener(eventType, preventDefault, { passive: false });\n    });\n\n    // Cleanup\n    return () => {\n      events.forEach((eventType) => {\n        element.removeEventListener(eventType, preventDefault);\n      });\n    };\n  }, [elementRef, enabled, events]);\n}\n\n/**\n * Hook that combines multiple pointer event patterns for drag operations\n */\nexport function useDragPointerEvents(\n  elementRef: React.RefObject<HTMLElement | null>,\n  enabled: boolean,\n  options: {\n    onMove?: (e: PointerEvent) => void;\n    onUp?: (e: PointerEvent) => void;\n    onCancel?: (e: PointerEvent) => void;\n    pointerId?: number;\n    capturePointer?: boolean;\n    preventDefaults?: boolean;\n  },\n) {\n  const { onMove, onUp, onCancel, pointerId, capturePointer = true, preventDefaults = true } = options;\n\n  // Document-level event handlers\n  useDocumentPointerEvents(enabled, { onMove, onUp, onCancel });\n\n  // Pointer capture\n  const shouldCapturePointer = enabled ? capturePointer : false;\n  usePointerCapture(elementRef, shouldCapturePointer, pointerId);\n\n  // Prevent defaults\n  const shouldPreventDefaults = enabled ? preventDefaults : false;\n  usePreventPointerDefaults(elementRef, shouldPreventDefaults);\n}\n"],"names":["useEffectEvent","fn","ref","React","args","currentFn","useDocumentPointerEvents","enabled","handlers","handleMoveEvent","handleUpEvent","handleCancelEvent","usePointerCapture","elementRef","pointerId","element","usePreventPointerDefaults","events","preventDefault","e","eventType","useDragPointerEvents","options","onMove","onUp","onCancel","capturePointer","preventDefaults"],"mappings":";AA0BO,SAASA,EACdC,GACuC;AACvC,QAAMC,IAAMC,EAAM,OAAkBF,CAAE;AACtC,SAAAC,EAAI,UAAUD,GAEPE,EAAM,YAAY,IAAIC,MAAmC;AAC9D,UAAMC,IAAYH,EAAI;AACtB,QAAIG;AACF,aAAOA,EAAU,GAAGD,CAAI;AAAA,EAG5B,GAAG,CAAA,CAAE;AACP;ACtBO,SAASE,EAAyBC,GAAkBC,GAA2C;AACpG,QAAMC,IAAkBT,EAAeQ,EAAS,MAAM,GAChDE,IAAgBV,EAAeQ,EAAS,IAAI,GAC5CG,IAAoBX,EAAeQ,EAAS,QAAQ;AAE1D,EAAAL,EAAM,UAAU,MAAM;AACpB,QAAKI;AAIL,aAAIC,EAAS,UACX,SAAS,iBAAiB,eAAeC,GAAiB,EAAE,SAAS,IAAO,GAE1ED,EAAS,QACX,SAAS,iBAAiB,aAAaE,CAAa,GAElDF,EAAS,YACX,SAAS,iBAAiB,iBAAiBG,CAAiB,GAIvD,MAAM;AACX,QAAIH,EAAS,UACX,SAAS,oBAAoB,eAAeC,CAAe,GAEzDD,EAAS,QACX,SAAS,oBAAoB,aAAaE,CAAa,GAErDF,EAAS,YACX,SAAS,oBAAoB,iBAAiBG,CAAiB;AAAA,MAEnE;AAAA,EACF,GAAG,CAACJ,GAASC,EAAS,QAAQA,EAAS,MAAMA,EAAS,UAAUC,GAAiBC,GAAeC,CAAiB,CAAC;AACpH;AAOO,SAASC,EAAkBC,GAAiDN,GAAkBO,GAAoB;AACvH,EAAAX,EAAM,UAAU,MAAM;AACpB,UAAMY,IAAUF,EAAW;AAC3B,QAAI,GAACN,KAAW,CAACQ,KAAWD,MAAc;AAK1C,aAAAC,EAAQ,kBAAkBD,CAAS,GAG5B,MAAM;AACX,QAAIC,EAAQ,qBAAqBA,EAAQ,kBAAkBD,CAAS,KAClEC,EAAQ,sBAAsBD,CAAS;AAAA,MAE3C;AAAA,EACF,GAAG,CAACD,GAAYN,GAASO,CAAS,CAAC;AACrC;AAMO,SAASE,EACdH,GACAN,GACAU,IAAmB,CAAC,eAAe,eAAe,WAAW,GAC7D;AACA,EAAAd,EAAM,UAAU,MAAM;AACpB,UAAMY,IAAUF,EAAW;AAC3B,QAAI,CAACN,KAAW,CAACQ;AACf;AAGF,UAAMG,IAAiB,CAACC,MAAa;AACnC,MAAAA,EAAE,eAAA;AAAA,IACJ;AAGA,WAAAF,EAAO,QAAQ,CAACG,MAAc;AAC5B,MAAAL,EAAQ,iBAAiBK,GAAWF,GAAgB,EAAE,SAAS,IAAO;AAAA,IACxE,CAAC,GAGM,MAAM;AACX,MAAAD,EAAO,QAAQ,CAACG,MAAc;AAC5B,QAAAL,EAAQ,oBAAoBK,GAAWF,CAAc;AAAA,MACvD,CAAC;AAAA,IACH;AAAA,EACF,GAAG,CAACL,GAAYN,GAASU,CAAM,CAAC;AAClC;AAKO,SAASI,EACdR,GACAN,GACAe,GAQA;AACA,QAAM,EAAE,QAAAC,GAAQ,MAAAC,GAAM,UAAAC,GAAU,WAAAX,GAAW,gBAAAY,IAAiB,IAAM,iBAAAC,IAAkB,GAAA,IAASL;AAG7F,EAAAhB,EAAyBC,GAAS,EAAE,QAAAgB,GAAQ,MAAAC,GAAM,UAAAC,GAAU,GAI5Db,EAAkBC,GADWN,IAAUmB,IAAiB,IACJZ,CAAS,GAI7DE,EAA0BH,GADIN,IAAUoB,IAAkB,EACC;AAC7D;"}

package/dist/useDocumentPointerEvents-DxDSOtip.cjs

@@ -0,0 +1,2 @@
+"use strict";const p=require("react");function E(o){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(o){for(const t in o)if(t!=="default"){const n=Object.getOwnPropertyDescriptor(o,t);Object.defineProperty(e,t,n.get?n:{enumerable:!0,get:()=>o[t]})}}return e.default=o,Object.freeze(e)}const c=E(p);function i(o){const e=c.useRef(o);return e.current=o,c.useCallback((...t)=>{const n=e.current;if(n)return n(...t)},[])}function s(o,e){const t=i(e.onMove),n=i(e.onUp),r=i(e.onCancel);c.useEffect(()=>{if(o)return e.onMove&&document.addEventListener("pointermove",t,{passive:!1}),e.onUp&&document.addEventListener("pointerup",n),e.onCancel&&document.addEventListener("pointercancel",r),()=>{e.onMove&&document.removeEventListener("pointermove",t),e.onUp&&document.removeEventListener("pointerup",n),e.onCancel&&document.removeEventListener("pointercancel",r)}},[o,e.onMove,e.onUp,e.onCancel,t,n,r])}function l(o,e,t){c.useEffect(()=>{const n=o.current;if(!(!e||!n||t===void 0))return n.setPointerCapture(t),()=>{n.hasPointerCapture&&n.hasPointerCapture(t)&&n.releasePointerCapture(t)}},[o,e,t])}function m(o,e,t=["pointerdown","pointermove","pointerup"]){c.useEffect(()=>{const n=o.current;if(!e||!n)return;const r=u=>{u.preventDefault()};return t.forEach(u=>{n.addEventListener(u,r,{passive:!1})}),()=>{t.forEach(u=>{n.removeEventListener(u,r)})}},[o,e,t])}function P(o,e,t){const{onMove:n,onUp:r,onCancel:u,pointerId:f,capturePointer:a=!0,preventDefaults:v=!0}=t;s(e,{onMove:n,onUp:r,onCancel:u}),l(o,e?a:!1,f),m(o,e?v:!1)}exports.useDocumentPointerEvents=s;exports.useDragPointerEvents=P;exports.useEffectEvent=i;
+//# sourceMappingURL=useDocumentPointerEvents-DxDSOtip.cjs.map

package/dist/useDocumentPointerEvents-DxDSOtip.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocumentPointerEvents-DxDSOtip.cjs","sources":["../src/hooks/useEffectEvent.ts","../src/hooks/useDocumentPointerEvents.ts"],"sourcesContent":["/**\n * @file useEffectEvent hook - Stable event handler for Effects\n *\n * This hook allows you to extract event handlers from Effects without causing them to re-run.\n * The returned function is stable and can be safely used in effect dependencies.\n *\n * @see https://react.dev/learn/separating-events-from-effects#declaring-an-effect-event\n */\nimport * as React from \"react\";\n\n/**\n * Extract event handlers from Effects to avoid unnecessary re-runs\n *\n * @example\n * ```tsx\n * function Component({ onEvent }) {\n *   const onEventHandler = useEffectEvent(onEvent);\n *\n *   React.useEffect(() => {\n *     // onEventHandler is stable, but always calls the latest onEvent\n *     const cleanup = subscribe(onEventHandler);\n *     return cleanup;\n *   }, []); // No need to include onEvent in dependencies\n * }\n * ```\n */\nexport function useEffectEvent<Args extends unknown[], Return>(\n  fn: ((...args: Args) => Return) | undefined,\n): (...args: Args) => Return | undefined {\n  const ref = React.useRef<typeof fn>(fn);\n  ref.current = fn;\n\n  return React.useCallback((...args: Args): Return | undefined => {\n    const currentFn = ref.current;\n    if (currentFn) {\n      return currentFn(...args);\n    }\n    return undefined;\n  }, []);\n}\n","/**\n * @file Hooks for managing document-level pointer events with proper cleanup\n */\nimport * as React from \"react\";\nimport { useEffectEvent } from \"./useEffectEvent\";\n\nexport type UseDocumentPointerEventsOptions = {\n  onMove?: (e: PointerEvent) => void;\n  onUp?: (e: PointerEvent) => void;\n  onCancel?: (e: PointerEvent) => void;\n};\n\n/**\n * Custom hook for managing document-level pointer events with proper cleanup\n * This pattern is commonly used for drag operations that need to continue\n * even when the pointer moves outside the original element\n */\nexport function useDocumentPointerEvents(enabled: boolean, handlers: UseDocumentPointerEventsOptions) {\n  const handleMoveEvent = useEffectEvent(handlers.onMove);\n  const handleUpEvent = useEffectEvent(handlers.onUp);\n  const handleCancelEvent = useEffectEvent(handlers.onCancel);\n\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    if (handlers.onMove) {\n      document.addEventListener(\"pointermove\", handleMoveEvent, { passive: false });\n    }\n    if (handlers.onUp) {\n      document.addEventListener(\"pointerup\", handleUpEvent);\n    }\n    if (handlers.onCancel) {\n      document.addEventListener(\"pointercancel\", handleCancelEvent);\n    }\n\n    // Cleanup function\n    return () => {\n      if (handlers.onMove) {\n        document.removeEventListener(\"pointermove\", handleMoveEvent);\n      }\n      if (handlers.onUp) {\n        document.removeEventListener(\"pointerup\", handleUpEvent);\n      }\n      if (handlers.onCancel) {\n        document.removeEventListener(\"pointercancel\", handleCancelEvent);\n      }\n    };\n  }, [enabled, handlers.onMove, handlers.onUp, handlers.onCancel, handleMoveEvent, handleUpEvent, handleCancelEvent]);\n}\n\n/**\n * Hook for capturing pointer during drag operations\n * This ensures that pointer events are delivered to the capturing element\n * even when the pointer moves outside its boundaries\n */\nexport function usePointerCapture(elementRef: React.RefObject<HTMLElement | null>, enabled: boolean, pointerId?: number) {\n  React.useEffect(() => {\n    const element = elementRef.current;\n    if (!enabled || !element || pointerId === undefined) {\n      return;\n    }\n\n    // Capture pointer\n    element.setPointerCapture(pointerId);\n\n    // Release capture on cleanup\n    return () => {\n      if (element.hasPointerCapture && element.hasPointerCapture(pointerId)) {\n        element.releasePointerCapture(pointerId);\n      }\n    };\n  }, [elementRef, enabled, pointerId]);\n}\n\n/**\n * Hook for preventing default pointer events during operations\n * Useful for preventing text selection, context menus, etc. during drag operations\n */\nexport function usePreventPointerDefaults(\n  elementRef: React.RefObject<HTMLElement | null>,\n  enabled: boolean,\n  events: string[] = [\"pointerdown\", \"pointermove\", \"pointerup\"],\n) {\n  React.useEffect(() => {\n    const element = elementRef.current;\n    if (!enabled || !element) {\n      return;\n    }\n\n    const preventDefault = (e: Event) => {\n      e.preventDefault();\n    };\n\n    // Add listeners\n    events.forEach((eventType) => {\n      element.addEventListener(eventType, preventDefault, { passive: false });\n    });\n\n    // Cleanup\n    return () => {\n      events.forEach((eventType) => {\n        element.removeEventListener(eventType, preventDefault);\n      });\n    };\n  }, [elementRef, enabled, events]);\n}\n\n/**\n * Hook that combines multiple pointer event patterns for drag operations\n */\nexport function useDragPointerEvents(\n  elementRef: React.RefObject<HTMLElement | null>,\n  enabled: boolean,\n  options: {\n    onMove?: (e: PointerEvent) => void;\n    onUp?: (e: PointerEvent) => void;\n    onCancel?: (e: PointerEvent) => void;\n    pointerId?: number;\n    capturePointer?: boolean;\n    preventDefaults?: boolean;\n  },\n) {\n  const { onMove, onUp, onCancel, pointerId, capturePointer = true, preventDefaults = true } = options;\n\n  // Document-level event handlers\n  useDocumentPointerEvents(enabled, { onMove, onUp, onCancel });\n\n  // Pointer capture\n  const shouldCapturePointer = enabled ? capturePointer : false;\n  usePointerCapture(elementRef, shouldCapturePointer, pointerId);\n\n  // Prevent defaults\n  const shouldPreventDefaults = enabled ? preventDefaults : false;\n  usePreventPointerDefaults(elementRef, shouldPreventDefaults);\n}\n"],"names":["useEffectEvent","fn","ref","React","args","currentFn","useDocumentPointerEvents","enabled","handlers","handleMoveEvent","handleUpEvent","handleCancelEvent","usePointerCapture","elementRef","pointerId","element","usePreventPointerDefaults","events","preventDefault","e","eventType","useDragPointerEvents","options","onMove","onUp","onCancel","capturePointer","preventDefaults"],"mappings":"gUA0BO,SAASA,EACdC,EACuC,CACvC,MAAMC,EAAMC,EAAM,OAAkBF,CAAE,EACtC,OAAAC,EAAI,QAAUD,EAEPE,EAAM,YAAY,IAAIC,IAAmC,CAC9D,MAAMC,EAAYH,EAAI,QACtB,GAAIG,EACF,OAAOA,EAAU,GAAGD,CAAI,CAG5B,EAAG,CAAA,CAAE,CACP,CCtBO,SAASE,EAAyBC,EAAkBC,EAA2C,CACpG,MAAMC,EAAkBT,EAAeQ,EAAS,MAAM,EAChDE,EAAgBV,EAAeQ,EAAS,IAAI,EAC5CG,EAAoBX,EAAeQ,EAAS,QAAQ,EAE1DL,EAAM,UAAU,IAAM,CACpB,GAAKI,EAIL,OAAIC,EAAS,QACX,SAAS,iBAAiB,cAAeC,EAAiB,CAAE,QAAS,GAAO,EAE1ED,EAAS,MACX,SAAS,iBAAiB,YAAaE,CAAa,EAElDF,EAAS,UACX,SAAS,iBAAiB,gBAAiBG,CAAiB,EAIvD,IAAM,CACPH,EAAS,QACX,SAAS,oBAAoB,cAAeC,CAAe,EAEzDD,EAAS,MACX,SAAS,oBAAoB,YAAaE,CAAa,EAErDF,EAAS,UACX,SAAS,oBAAoB,gBAAiBG,CAAiB,CAEnE,CACF,EAAG,CAACJ,EAASC,EAAS,OAAQA,EAAS,KAAMA,EAAS,SAAUC,EAAiBC,EAAeC,CAAiB,CAAC,CACpH,CAOO,SAASC,EAAkBC,EAAiDN,EAAkBO,EAAoB,CACvHX,EAAM,UAAU,IAAM,CACpB,MAAMY,EAAUF,EAAW,QAC3B,GAAI,GAACN,GAAW,CAACQ,GAAWD,IAAc,QAK1C,OAAAC,EAAQ,kBAAkBD,CAAS,EAG5B,IAAM,CACPC,EAAQ,mBAAqBA,EAAQ,kBAAkBD,CAAS,GAClEC,EAAQ,sBAAsBD,CAAS,CAE3C,CACF,EAAG,CAACD,EAAYN,EAASO,CAAS,CAAC,CACrC,CAMO,SAASE,EACdH,EACAN,EACAU,EAAmB,CAAC,cAAe,cAAe,WAAW,EAC7D,CACAd,EAAM,UAAU,IAAM,CACpB,MAAMY,EAAUF,EAAW,QAC3B,GAAI,CAACN,GAAW,CAACQ,EACf,OAGF,MAAMG,EAAkBC,GAAa,CACnCA,EAAE,eAAA,CACJ,EAGA,OAAAF,EAAO,QAASG,GAAc,CAC5BL,EAAQ,iBAAiBK,EAAWF,EAAgB,CAAE,QAAS,GAAO,CACxE,CAAC,EAGM,IAAM,CACXD,EAAO,QAASG,GAAc,CAC5BL,EAAQ,oBAAoBK,EAAWF,CAAc,CACvD,CAAC,CACH,CACF,EAAG,CAACL,EAAYN,EAASU,CAAM,CAAC,CAClC,CAKO,SAASI,EACdR,EACAN,EACAe,EAQA,CACA,KAAM,CAAE,OAAAC,EAAQ,KAAAC,EAAM,SAAAC,EAAU,UAAAX,EAAW,eAAAY,EAAiB,GAAM,gBAAAC,EAAkB,EAAA,EAASL,EAG7FhB,EAAyBC,EAAS,CAAE,OAAAgB,EAAQ,KAAAC,EAAM,SAAAC,EAAU,EAI5Db,EAAkBC,EADWN,EAAUmB,EAAiB,GACJZ,CAAS,EAI7DE,EAA0BH,EADIN,EAAUoB,EAAkB,EACC,CAC7D"}

package/dist/useNativeGestureGuard-C7TSqEkr.cjs

@@ -0,0 +1,2 @@
+"use strict";const V=require("react"),D=require("./useDocumentPointerEvents-DxDSOtip.cjs");function q(o){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(o){for(const n in o)if(n!=="default"){const t=Object.getOwnPropertyDescriptor(o,n);Object.defineProperty(e,n,t.get?t:{enumerable:!0,get:()=>o[n]})}}return e.default=o,Object.freeze(e)}const c=q(V),R={isDown:!1,start:null,current:null,pointerId:null,wasCanceled:!1},U=(o,e)=>({x:o,y:e,timestamp:performance.now()});function G(o){const{enabled:e,primaryOnly:n=!0}=o,[t,r]=c.useState(R),i=c.useCallback(()=>{r(R)},[]),l=D.useEffectEvent(a=>{if(!e||n&&!a.isPrimary||a.pointerType==="mouse"&&a.button!==0)return;const m=U(a.clientX,a.clientY);r({isDown:!0,start:m,current:m,pointerId:a.pointerId,wasCanceled:!1})}),f=D.useEffectEvent(a=>{if(t.pointerId!==a.pointerId)return;const m=U(a.clientX,a.clientY);r(w=>({...w,current:m}))}),d=D.useEffectEvent(()=>{r(R)}),h=D.useEffectEvent(()=>{r({...R,wasCanceled:!0})}),s=t.isDown?e:!1;return D.useDocumentPointerEvents(s,{onMove:f,onUp:d,onCancel:h}),c.useEffect(()=>{!e&&t.isDown&&i()},[e,t.isDown,i]),{state:t,onPointerDown:l,reset:i}}const K=10,Z=(o,e)=>{const n=Math.abs(o),t=Math.abs(e);return n===0&&t===0?null:n>t*1.5?"horizontal":t>n*1.5?"vertical":null};function J(o){const{tracking:e,lockThreshold:n=K}=o,[t,r]=c.useState(null),i=c.useCallback(()=>{r(null)},[]);return c.useEffect(()=>{if(!e.isDown){t!==null&&i();return}if(t!==null||!e.start||!e.current)return;const l=e.current.x-e.start.x,f=e.current.y-e.start.y;if(Math.max(Math.abs(l),Math.abs(f))<n)return;const h=Z(l,f);h!==null&&r(h)},[e.isDown,e.start,e.current,t,n,i]),{lockedAxis:t,isLocked:t!==null,reset:i}}const H=(o,e,n)=>{const t=n-e;return t<=0?0:o/t},_=o=>o>0?1:o<0?-1:0,Q=(...o)=>{const e={},n=[];for(const r of o)Object.assign(e,r.style),r.onPointerDown&&n.push(r.onPointerDown);return{onPointerDown:r=>{for(const i of n)i?.(r)},style:e}};function $(o,e,n,t){let r=o;for(;r!==null&&r!==e;){const i=getComputedStyle(r),l=n==="x",f=l?i.overflowX:i.overflowY;if(f==="scroll"||f==="auto"){const h=l?r.scrollWidth-r.clientWidth:r.scrollHeight-r.clientHeight;if(h>0){const s=l?r.scrollLeft:r.scrollTop;if(t===-1&&s>1||t===1&&s<h-1)return!0}}r=r.parentElement}return!1}const ee={phase:"idle",displacement:{x:0,y:0},velocity:{x:0,y:0}},B={distanceThreshold:100,velocityThreshold:.5,lockThreshold:10},F=20,x={phase:"idle",displacement:{x:0,y:0},velocity:{x:0,y:0},direction:0},te=150,N=(o,e,n,t,r)=>{const i=n==="horizontal"?o.x:o.y,l=n==="horizontal"?e.x:e.y,f=Math.abs(i),d=Math.abs(l);if(f>=t.distanceThreshold||d>=t.velocityThreshold){const s=_(i);r?.({phase:"ended",displacement:o,velocity:e,direction:s})}};function ne(o){const{containerRef:e,axis:n,enabled:t=!0,thresholds:r,onSwipeEnd:i,enableWheel:l=!0,pointerStartFilter:f}=o,d={...B,...r},h=D.useEffectEvent(i),{state:s,onPointerDown:a}=G({enabled:t}),m=c.useCallback(u=>{if(t){if(f){const p=e.current;if(!p||!f(u,p))return}a(u)}},[t,f,e,a]),{lockedAxis:w,isLocked:b}=J({tracking:s,lockThreshold:d.lockThreshold}),S=c.useRef(null),k=c.useRef(!1);c.useEffect(()=>{k.current=b?w===n:!1},[b,w,n]),c.useEffect(()=>{const u=e.current;if(!u||!t)return;const p=y=>{y.preventDefault()},E=y=>{k.current&&y.preventDefault(),document.addEventListener("touchmove",p,{passive:!1})},v=()=>{document.removeEventListener("touchmove",p)};return document.addEventListener("touchend",v),document.addEventListener("touchcancel",v),u.addEventListener("touchstart",E,{passive:!1}),()=>{u.removeEventListener("touchstart",E),document.removeEventListener("touchend",v),document.removeEventListener("touchcancel",v)}},[e,t]);const[I,C]=c.useState(x),g=c.useRef({x:0,y:0}),T=c.useRef(null),L=c.useRef(!1),O=c.useRef(null),A=c.useCallback(()=>{g.current={x:0,y:0},L.current=!1,O.current=null,C(x)},[]),X=c.useCallback(()=>{const u={...g.current};N(u,{x:0,y:0},n,d,h),A()},[n,d,h,A]),M=D.useEffectEvent(u=>{if(!t||!l||s.isDown)return;const{deltaX:p,deltaY:E}=u;if(!L.current){const W=Math.abs(p),z=Math.abs(E);(W>=d.lockThreshold||z>=d.lockThreshold)&&(L.current=!0,O.current=W>z?"horizontal":"vertical")}if(L.current&&O.current!==n)return;g.current.x-=p,g.current.y-=E;const v=g.current,y=n==="horizontal"?v.x:v.y;C({phase:"swiping",displacement:{...v},velocity:{x:0,y:0},direction:_(y)}),T.current!==null&&clearTimeout(T.current),T.current=setTimeout(X,te)});c.useEffect(()=>{const u=e.current;if(!u||!t||!l)return;const p=E=>{E.preventDefault(),M(E)};return u.addEventListener("wheel",p,{passive:!1}),()=>{u.removeEventListener("wheel",p),T.current!==null&&clearTimeout(T.current)}},[e,t,l,M]),c.useEffect(()=>()=>{T.current!==null&&clearTimeout(T.current)},[]);const P=c.useMemo(()=>{if(!s.isDown||!s.start||!s.current)return x;const u=s.current.x-s.start.x,p=s.current.y-s.start.y,E={x:u,y:p},v={x:H(u,s.start.timestamp,s.current.timestamp),y:H(p,s.start.timestamp,s.current.timestamp)};return!b||w!==n?{phase:"tracking",displacement:E,velocity:v,direction:0}:{phase:"swiping",displacement:E,velocity:v,direction:_(n==="horizontal"?u:p)}},[s.isDown,s.start,s.current,b,w,n]);c.useEffect(()=>{P.phase!=="idle"&&(S.current=P)},[P]),c.useEffect(()=>{if(s.isDown)return;const u=S.current;!u||u.phase!=="swiping"&&u.phase!=="tracking"||(S.current=null,!s.wasCanceled&&N(u.displacement,u.velocity,n,d,h))},[s.isDown,s.wasCanceled,n,d,h]);const Y=P.phase!=="idle"?P:I,j=c.useMemo(()=>({onPointerDown:m,style:{touchAction:n==="horizontal"?"pan-y pinch-zoom":"pan-x pinch-zoom",userSelect:"none",WebkitUserSelect:"none"}}),[n,m]);return{state:Y,containerProps:j}}const re=o=>o==="left"||o==="right"?"horizontal":"vertical",oe=(o,e,n,t,r)=>{const i=n.getBoundingClientRect();switch(t){case"left":return o>=i.left&&o<=i.left+r;case"right":return o>=i.right-r&&o<=i.right;case"top":return e>=i.top&&e<=i.top+r;case"bottom":return e>=i.bottom-r&&e<=i.bottom}};function se(o){const{containerRef:e,edge:n,edgeWidth:t=F,enabled:r=!0,thresholds:i,onSwipeEnd:l}=o,f={...B,...i},d=re(n),[h,s]=c.useState(!1),a=c.useCallback((S,k)=>{const I=oe(S.clientX,S.clientY,k,n,t);return s(I),I},[n,t]),{state:m,containerProps:w}=ne({containerRef:e,axis:d,enabled:r,thresholds:f,onSwipeEnd:l,enableWheel:!1,pointerStartFilter:a});return c.useEffect(()=>{m.phase==="idle"&&s(!1)},[m.phase]),{isEdgeGesture:h,state:h?m:x,containerProps:w}}const ce=(o,e,n)=>{const t=e.getBoundingClientRect();return o>=t.left&&o<=t.left+n};function ie(o){const{containerRef:e,active:n,preventEdgeBack:t=!0,preventOverscroll:r=!0,edgeWidth:i=F}=o,l=c.useRef(null),f=c.useCallback(()=>{if(!r)return;const s=document.documentElement;l.current===null&&(l.current=s.style.overscrollBehavior),s.style.overscrollBehavior="none"},[r]);c.useEffect(()=>{n||!r||l.current!==null&&(document.documentElement.style.overscrollBehavior=l.current,l.current=null)},[n,r]),c.useEffect(()=>()=>{l.current!==null&&(document.documentElement.style.overscrollBehavior=l.current,l.current=null)},[]);const d=c.useCallback(s=>{if(!t)return;const a=e.current;a&&s.pointerType==="touch"&&ce(s.clientX,a,i)&&(f(),s.preventDefault())},[t,e,i,f]);return{containerProps:c.useMemo(()=>({onPointerDown:t?d:void 0,style:{overscrollBehavior:r?"contain":void 0,WebkitOverflowScrolling:"touch"}}),[r,t,d])}}exports.IDLE_CONTINUOUS_OPERATION_STATE=ee;exports.IDLE_SWIPE_INPUT_STATE=x;exports.isScrollableInDirection=$;exports.mergeGestureContainerProps=Q;exports.useEdgeSwipeInput=se;exports.useNativeGestureGuard=ie;exports.usePointerTracking=G;
+//# sourceMappingURL=useNativeGestureGuard-C7TSqEkr.cjs.map

package/dist/useNativeGestureGuard-C7TSqEkr.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNativeGestureGuard-C7TSqEkr.cjs","sources":["../src/hooks/gesture/usePointerTracking.ts","../src/hooks/gesture/useDirectionalLock.ts","../src/hooks/gesture/utils.ts","../src/hooks/gesture/types.ts","../src/hooks/gesture/useSwipeInput.ts","../src/hooks/gesture/useEdgeSwipeInput.ts","../src/hooks/gesture/useNativeGestureGuard.ts"],"sourcesContent":["/**\n * @file Hook for tracking pointer state during gestures.\n *\n * Provides low-level pointer tracking with position, velocity, and timing.\n * This hook serves as the foundation for higher-level gesture hooks.\n */\nimport * as React from \"react\";\nimport { useDocumentPointerEvents } from \"../useDocumentPointerEvents.js\";\nimport { useEffectEvent } from \"../useEffectEvent.js\";\nimport type {\n  PointerTrackingState,\n  TimestampedPoint,\n  UsePointerTrackingOptions,\n  UsePointerTrackingResult,\n} from \"./types.js\";\n\n/**\n * Initial state for pointer tracking.\n */\nconst INITIAL_STATE: PointerTrackingState = {\n  isDown: false,\n  start: null,\n  current: null,\n  pointerId: null,\n  wasCanceled: false,\n};\n\n/**\n * Creates a timestamped point from pointer event coordinates.\n */\nconst createTimestampedPoint = (clientX: number, clientY: number): TimestampedPoint => ({\n  x: clientX,\n  y: clientY,\n  timestamp: performance.now(),\n});\n\n/**\n * Hook for tracking pointer state during gestures.\n *\n * Tracks pointer down/move/up events and provides position and timing data\n * that can be used by higher-level gesture detection hooks.\n *\n * @example\n * ```tsx\n * const { state, onPointerDown, reset } = usePointerTracking({\n *   enabled: true,\n *   primaryOnly: true,\n * });\n *\n * return (\n *   <div onPointerDown={onPointerDown}>\n *     {state.isDown && <span>Tracking...</span>}\n *   </div>\n * );\n * ```\n */\nexport function usePointerTracking(options: UsePointerTrackingOptions): UsePointerTrackingResult {\n  const { enabled, primaryOnly = true } = options;\n\n  const [state, setState] = React.useState<PointerTrackingState>(INITIAL_STATE);\n\n  const reset = React.useCallback(() => {\n    setState(INITIAL_STATE);\n  }, []);\n\n  const handlePointerDown = useEffectEvent((event: React.PointerEvent) => {\n    if (!enabled) {\n      return;\n    }\n\n    // Filter non-primary pointers if primaryOnly is set\n    if (primaryOnly && !event.isPrimary) {\n      return;\n    }\n\n    // Only track left mouse button or touch/pen\n    if (event.pointerType === \"mouse\" && event.button !== 0) {\n      return;\n    }\n\n    const point = createTimestampedPoint(event.clientX, event.clientY);\n\n    setState({\n      isDown: true,\n      start: point,\n      current: point,\n      pointerId: event.pointerId,\n      wasCanceled: false,\n    });\n  });\n\n  const handlePointerMove = useEffectEvent((event: PointerEvent) => {\n    // Verify this is the tracked pointer\n    if (state.pointerId !== event.pointerId) {\n      return;\n    }\n\n    const point = createTimestampedPoint(event.clientX, event.clientY);\n\n    setState((prev) => ({\n      ...prev,\n      current: point,\n    }));\n  });\n\n  const handlePointerUp = useEffectEvent(() => {\n    setState(INITIAL_STATE);\n  });\n\n  const handlePointerCancel = useEffectEvent(() => {\n    setState({ ...INITIAL_STATE, wasCanceled: true });\n  });\n\n  // Use document-level pointer events for tracking after pointer down\n  const shouldTrackDocument = state.isDown ? enabled : false;\n  useDocumentPointerEvents(shouldTrackDocument, {\n    onMove: handlePointerMove,\n    onUp: handlePointerUp,\n    onCancel: handlePointerCancel,\n  });\n\n  // Reset state when disabled\n  React.useEffect(() => {\n    if (!enabled && state.isDown) {\n      reset();\n    }\n  }, [enabled, state.isDown, reset]);\n\n  return {\n    state,\n    onPointerDown: handlePointerDown,\n    reset,\n  };\n}\n","/**\n * @file Hook for locking gesture direction after threshold is exceeded.\n *\n * Once the user moves beyond the lock threshold, the direction is locked\n * to either horizontal or vertical, preventing diagonal gestures from\n * triggering both scroll and swipe.\n */\nimport * as React from \"react\";\nimport type {\n  GestureAxis,\n  UseDirectionalLockOptions,\n  UseDirectionalLockResult,\n} from \"./types.js\";\n\nconst DEFAULT_LOCK_THRESHOLD = 10;\n\n/**\n * Determines which axis the gesture is primarily moving along.\n *\n * @param deltaX - Horizontal displacement from start\n * @param deltaY - Vertical displacement from start\n * @returns The dominant axis, or null if movement is insufficient\n */\nconst determineAxis = (deltaX: number, deltaY: number): GestureAxis | null => {\n  const absX = Math.abs(deltaX);\n  const absY = Math.abs(deltaY);\n\n  // Require at least some movement in one direction\n  if (absX === 0 && absY === 0) {\n    return null;\n  }\n\n  // Use a 1.5x ratio to ensure clear direction before locking\n  // This prevents near-diagonal gestures from locking prematurely\n  if (absX > absY * 1.5) {\n    return \"horizontal\";\n  }\n\n  if (absY > absX * 1.5) {\n    return \"vertical\";\n  }\n\n  // Still ambiguous\n  return null;\n};\n\n/**\n * Hook for locking gesture direction after threshold is exceeded.\n *\n * This hook tracks pointer movement and locks to horizontal or vertical\n * direction once the movement exceeds the configured threshold. This\n * prevents diagonal gestures from triggering both scroll and swipe behaviors.\n *\n * @example\n * ```tsx\n * const { state: tracking, onPointerDown } = usePointerTracking({ enabled: true });\n * const { lockedAxis, isLocked } = useDirectionalLock({\n *   tracking,\n *   lockThreshold: 10,\n * });\n *\n * // lockedAxis will be \"horizontal\" or \"vertical\" once determined\n * ```\n */\nexport function useDirectionalLock(options: UseDirectionalLockOptions): UseDirectionalLockResult {\n  const { tracking, lockThreshold = DEFAULT_LOCK_THRESHOLD } = options;\n\n  const [lockedAxis, setLockedAxis] = React.useState<GestureAxis | null>(null);\n\n  const reset = React.useCallback(() => {\n    setLockedAxis(null);\n  }, []);\n\n  // Determine direction when tracking is active\n  React.useEffect(() => {\n    // Reset lock when pointer is released\n    if (!tracking.isDown) {\n      if (lockedAxis !== null) {\n        reset();\n      }\n      return;\n    }\n\n    // Already locked, no need to recalculate\n    if (lockedAxis !== null) {\n      return;\n    }\n\n    // Need start and current positions\n    if (!tracking.start || !tracking.current) {\n      return;\n    }\n\n    const deltaX = tracking.current.x - tracking.start.x;\n    const deltaY = tracking.current.y - tracking.start.y;\n\n    // Check if we've exceeded the lock threshold\n    const distance = Math.max(Math.abs(deltaX), Math.abs(deltaY));\n    if (distance < lockThreshold) {\n      return;\n    }\n\n    // Try to determine axis\n    const axis = determineAxis(deltaX, deltaY);\n    if (axis !== null) {\n      setLockedAxis(axis);\n    }\n  }, [tracking.isDown, tracking.start, tracking.current, lockedAxis, lockThreshold, reset]);\n\n  return {\n    lockedAxis,\n    isLocked: lockedAxis !== null,\n    reset,\n  };\n}\n","/**\n * @file Utility functions for gesture detection hooks.\n *\n * Contains shared calculations and helper functions used across\n * gesture-related hooks to avoid code duplication.\n */\nimport type * as React from \"react\";\n\n/**\n * Calculate velocity from displacement and time elapsed.\n *\n * @param displacement - Distance traveled in pixels\n * @param startTime - Start timestamp in milliseconds\n * @param currentTime - Current timestamp in milliseconds\n * @returns Velocity in pixels per millisecond\n */\nexport const calculateVelocity = (\n  displacement: number,\n  startTime: number,\n  currentTime: number,\n): number => {\n  const elapsed = currentTime - startTime;\n  if (elapsed <= 0) {\n    return 0;\n  }\n  return displacement / elapsed;\n};\n\n/**\n * Determine direction from displacement.\n *\n * @param displacement - Distance from start position\n * @returns -1 for backward (left/up), 0 for no movement, 1 for forward (right/down)\n */\nexport const determineDirection = (displacement: number): -1 | 0 | 1 => {\n  if (displacement > 0) {\n    return 1;\n  }\n  if (displacement < 0) {\n    return -1;\n  }\n  return 0;\n};\n\n/**\n * Container props type for gesture handling.\n */\nexport type GestureContainerProps = React.HTMLAttributes<HTMLElement> & {\n  style: React.CSSProperties;\n};\n\n/**\n * Merge multiple container props objects for gesture handling.\n *\n * Combines style objects and chains onPointerDown handlers.\n * Useful when combining multiple gesture hooks that each provide\n * their own container props (e.g., swipe input + native gesture guard).\n *\n * @param propsArray - Array of container props to merge\n * @returns Merged container props with combined styles and handlers\n */\nexport const mergeGestureContainerProps = (\n  ...propsArray: GestureContainerProps[]\n): GestureContainerProps => {\n  const mergedStyle: React.CSSProperties = {};\n  const pointerDownHandlers: Array<\n    ((event: React.PointerEvent<HTMLElement>) => void) | undefined\n  > = [];\n\n  for (const props of propsArray) {\n    Object.assign(mergedStyle, props.style);\n    if (props.onPointerDown) {\n      pointerDownHandlers.push(props.onPointerDown);\n    }\n  }\n\n  const handlePointerDown = (event: React.PointerEvent<HTMLElement>) => {\n    for (const handler of pointerDownHandlers) {\n      handler?.(event);\n    }\n  };\n\n  return {\n    onPointerDown: handlePointerDown,\n    style: mergedStyle,\n  };\n};\n\n// ============================================================================\n// Scroll Detection Utilities\n// ============================================================================\n\n/**\n * Check if an element is scrollable in any direction.\n */\nexport function isScrollableElement(element: HTMLElement): boolean {\n  const style = getComputedStyle(element);\n\n  const isScrollableX =\n    (style.overflowX === \"scroll\" || style.overflowX === \"auto\") &&\n    element.scrollWidth > element.clientWidth;\n\n  const isScrollableY =\n    (style.overflowY === \"scroll\" || style.overflowY === \"auto\") &&\n    element.scrollHeight > element.clientHeight;\n\n  return isScrollableX || isScrollableY;\n}\n\n/**\n * Check if we should start drag based on scroll state.\n * Returns false if the target is inside a scrollable element.\n */\nexport function shouldStartDrag(\n  event: React.PointerEvent,\n  container: HTMLElement,\n): boolean {\n  // eslint-disable-next-line no-restricted-syntax -- loop variable requires let\n  let current = event.target as HTMLElement | null;\n\n  while (current !== null && current !== container) {\n    if (isScrollableElement(current)) {\n      return false;\n    }\n    current = current.parentElement;\n  }\n\n  return true;\n}\n\n/**\n * Check if an element or its ancestors are scrollable in the specified direction.\n * Returns true if scrolling is possible and would block the swipe gesture.\n *\n * @param element - The target element to check\n * @param container - The container boundary\n * @param axis - The axis to check (\"x\" or \"y\")\n * @param direction - The swipe direction (1 = right/down, -1 = left/up)\n */\nexport function isScrollableInDirection(\n  element: HTMLElement,\n  container: HTMLElement,\n  axis: \"x\" | \"y\",\n  direction: 1 | -1,\n): boolean {\n  // eslint-disable-next-line no-restricted-syntax -- loop variable requires let\n  let current: HTMLElement | null = element;\n\n  while (current !== null && current !== container) {\n    const style = getComputedStyle(current);\n    const isHorizontal = axis === \"x\";\n\n    const overflow = isHorizontal ? style.overflowX : style.overflowY;\n    const isScrollable = overflow === \"scroll\" || overflow === \"auto\";\n\n    if (isScrollable) {\n      const scrollSize = isHorizontal\n        ? current.scrollWidth - current.clientWidth\n        : current.scrollHeight - current.clientHeight;\n\n      if (scrollSize > 0) {\n        const scrollPos = isHorizontal ? current.scrollLeft : current.scrollTop;\n\n        // If swiping in close direction and not at boundary, block swipe\n        if (direction === -1 && scrollPos > 1) {\n          return true; // Can scroll left/up, block swipe\n        }\n        if (direction === 1 && scrollPos < scrollSize - 1) {\n          return true; // Can scroll right/down, block swipe\n        }\n      }\n    }\n\n    current = current.parentElement;\n  }\n\n  return false;\n}\n","/**\n * @file Type definitions for gesture input detection hooks.\n *\n * These types support the separation of concerns:\n * - Operation: what to do (navigate, push, pop)\n * - Input: how to command (swipe, click, keyboard)\n * - Presentation: how to show (animation, transition)\n *\n * This file defines types for the Input layer, including the abstract\n * ContinuousOperationState that represents any continuous state transition\n * (whether controlled by human gesture or system animation).\n */\nimport type * as React from \"react\";\n\n/**\n * Axis for gesture detection.\n */\nexport type GestureAxis = \"horizontal\" | \"vertical\";\n\n/**\n * 2D vector for displacement and velocity.\n */\nexport type Vector2 = {\n  x: number;\n  y: number;\n};\n\n// ============================================================================\n// Continuous Operation State\n// ============================================================================\n// A continuous operation is any state transition that occurs over time,\n// where progress can be observed incrementally. The controlling agent\n// may be human (gesture) or system (animation).\n\n/**\n * Phase of a continuous operation lifecycle.\n * - \"idle\": No operation in progress\n * - \"operating\": Operation is in progress (human or system controlled)\n * - \"ended\": Operation has completed\n */\nexport type ContinuousOperationPhase = \"idle\" | \"operating\" | \"ended\";\n\n/**\n * State of a continuous operation.\n *\n * This is the abstract representation of any operation that occurs over time,\n * whether controlled by human gesture or system animation. Components that\n * accept this state can respond to both input types uniformly.\n */\nexport type ContinuousOperationState = {\n  /** Current phase of the operation */\n  phase: ContinuousOperationPhase;\n  /** Displacement from start position in pixels */\n  displacement: Vector2;\n  /** Current velocity in pixels per millisecond */\n  velocity: Vector2;\n};\n\n/**\n * Initial idle state for ContinuousOperationState.\n */\nexport const IDLE_CONTINUOUS_OPERATION_STATE: ContinuousOperationState = {\n  phase: \"idle\",\n  displacement: { x: 0, y: 0 },\n  velocity: { x: 0, y: 0 },\n};\n\n/**\n * Convert SwipeInputPhase to ContinuousOperationPhase.\n * - \"idle\" → \"idle\"\n * - \"tracking\" | \"swiping\" → \"operating\"\n * - \"ended\" → \"ended\"\n */\nexport function toContinuousPhase(phase: SwipeInputPhase): ContinuousOperationPhase {\n  if (phase === \"idle\") {\n    return \"idle\";\n  }\n  if (phase === \"ended\") {\n    return \"ended\";\n  }\n  return \"operating\";\n}\n\n/**\n * Convert SwipeInputState to ContinuousOperationState.\n */\nexport function toContinuousOperationState(state: SwipeInputState): ContinuousOperationState {\n  return {\n    phase: toContinuousPhase(state.phase),\n    displacement: state.displacement,\n    velocity: state.velocity,\n  };\n}\n\n// ============================================================================\n// Swipe Input (concrete implementation of continuous operation)\n// ============================================================================\n\n/**\n * Phase of swipe input lifecycle.\n * - \"idle\": No swipe in progress\n * - \"tracking\": Pointer down, tracking movement (direction not yet locked)\n * - \"swiping\": Direction locked, actively swiping\n * - \"ended\": Swipe gesture completed\n */\nexport type SwipeInputPhase = \"idle\" | \"tracking\" | \"swiping\" | \"ended\";\n\n/**\n * Point with timestamp for velocity calculation.\n */\nexport type TimestampedPoint = {\n  x: number;\n  y: number;\n  timestamp: number;\n};\n\n/**\n * Swipe input state during gesture.\n */\nexport type SwipeInputState = {\n  /** Current phase of the swipe input */\n  phase: SwipeInputPhase;\n  /** Displacement from start position in pixels */\n  displacement: Vector2;\n  /** Current velocity in pixels per millisecond */\n  velocity: Vector2;\n  /**\n   * Direction of movement as a number.\n   * -1 = backward (left/up), 0 = no movement, 1 = forward (right/down)\n   */\n  direction: -1 | 0 | 1;\n};\n\n/**\n * Thresholds for swipe input recognition.\n */\nexport type SwipeInputThresholds = {\n  /** Minimum distance in pixels to trigger swipe. @default 50 */\n  distanceThreshold: number;\n  /** Minimum velocity in px/ms to trigger swipe. @default 0.3 */\n  velocityThreshold: number;\n  /** Distance threshold before direction is locked. @default 10 */\n  lockThreshold: number;\n};\n\n/**\n * Options for usePointerTracking hook.\n */\nexport type UsePointerTrackingOptions = {\n  /** Whether tracking is enabled */\n  enabled: boolean;\n  /** Restrict to primary pointer only (ignore multitouch). @default true */\n  primaryOnly?: boolean;\n};\n\n/**\n * Result from usePointerTracking hook.\n */\nexport type UsePointerTrackingResult = {\n  /** Current tracking state */\n  state: PointerTrackingState;\n  /** Handler to attach to onPointerDown */\n  onPointerDown: (event: React.PointerEvent) => void;\n  /** Reset tracking state */\n  reset: () => void;\n};\n\n/**\n * Internal pointer tracking state.\n */\nexport type PointerTrackingState = {\n  /** Whether pointer is currently down */\n  isDown: boolean;\n  /** Start position and timestamp */\n  start: TimestampedPoint | null;\n  /** Current position and timestamp */\n  current: TimestampedPoint | null;\n  /** Active pointer ID */\n  pointerId: number | null;\n  /** Whether tracking ended via pointercancel (not pointerup) */\n  wasCanceled: boolean;\n};\n\n/**\n * Options for useDirectionalLock hook.\n */\nexport type UseDirectionalLockOptions = {\n  /** Pointer tracking state from usePointerTracking */\n  tracking: PointerTrackingState;\n  /** Lock threshold in pixels. @default 10 */\n  lockThreshold?: number;\n};\n\n/**\n * Result from useDirectionalLock hook.\n */\nexport type UseDirectionalLockResult = {\n  /** Locked axis, or null if not yet locked */\n  lockedAxis: GestureAxis | null;\n  /** Whether lock has been determined */\n  isLocked: boolean;\n  /** Reset the lock state */\n  reset: () => void;\n};\n\n/**\n * Options for useScrollBoundary hook.\n */\nexport type UseScrollBoundaryOptions = {\n  /** Scroll container ref. If null, checks document scroll. */\n  containerRef: React.RefObject<HTMLElement | null>;\n  /** Axis to monitor */\n  axis: GestureAxis;\n  /** Tolerance in pixels for \"at boundary\" detection. @default 1 */\n  tolerance?: number;\n};\n\n/**\n * Result from useScrollBoundary hook.\n */\nexport type UseScrollBoundaryResult = {\n  /** Whether at the start boundary (top/left) */\n  atStart: boolean;\n  /** Whether at the end boundary (bottom/right) */\n  atEnd: boolean;\n  /** Current scroll position */\n  scrollPosition: number;\n  /** Maximum scroll position */\n  maxScrollPosition: number;\n};\n\n/**\n * Filter function to determine if a pointer event should start tracking.\n * Receives the pointer event and container element.\n * Return true to allow tracking, false to ignore the event.\n */\nexport type PointerStartFilter = (\n  event: React.PointerEvent,\n  container: HTMLElement,\n) => boolean;\n\n/**\n * Options for useSwipeInput hook.\n */\nexport type UseSwipeInputOptions = {\n  /** Ref to the container element */\n  containerRef: React.RefObject<HTMLElement | null>;\n  /** Axis to detect swipes on */\n  axis: GestureAxis;\n  /** Whether swipe detection is enabled. @default true */\n  enabled?: boolean;\n  /** Swipe thresholds configuration */\n  thresholds?: Partial<SwipeInputThresholds>;\n  /** Callback when swipe is completed */\n  onSwipeEnd?: (state: SwipeInputState) => void;\n  /** Whether to enable trackpad two-finger swipe (wheel events). @default true */\n  enableWheel?: boolean;\n  /**\n   * Optional filter to determine if a pointer event should start tracking.\n   * If provided, only events that pass this filter will be tracked.\n   * Useful for edge-based swipe detection.\n   */\n  pointerStartFilter?: PointerStartFilter;\n};\n\n/**\n * Result from useSwipeInput hook.\n */\nexport type UseSwipeInputResult = {\n  /** Current swipe input state */\n  state: SwipeInputState;\n  /** Props to spread on the container element */\n  containerProps: React.HTMLAttributes<HTMLElement> & {\n    style: React.CSSProperties;\n  };\n};\n\n/**\n * Edge for edge-originated gestures.\n */\nexport type GestureEdge = \"left\" | \"right\" | \"top\" | \"bottom\";\n\n/**\n * Options for useEdgeSwipeInput hook.\n */\nexport type UseEdgeSwipeInputOptions = {\n  /** Ref to the container element */\n  containerRef: React.RefObject<HTMLElement | null>;\n  /** Which edge to detect swipes from */\n  edge: GestureEdge;\n  /** Width of the edge detection zone in pixels. @default 20 */\n  edgeWidth?: number;\n  /** Whether edge swipe detection is enabled. @default true */\n  enabled?: boolean;\n  /** Swipe thresholds configuration */\n  thresholds?: Partial<SwipeInputThresholds>;\n  /** Callback when edge swipe is completed */\n  onSwipeEnd?: (state: SwipeInputState) => void;\n};\n\n/**\n * Result from useEdgeSwipeInput hook.\n */\nexport type UseEdgeSwipeInputResult = {\n  /** Whether the current gesture started from the edge */\n  isEdgeGesture: boolean;\n  /** Current swipe input state */\n  state: SwipeInputState;\n  /** Props to spread on the container element */\n  containerProps: React.HTMLAttributes<HTMLElement> & {\n    style: React.CSSProperties;\n  };\n};\n\n/**\n * Options for useNativeGestureGuard hook.\n */\nexport type UseNativeGestureGuardOptions = {\n  /** Ref to the container element */\n  containerRef: React.RefObject<HTMLElement | null>;\n  /** Whether the guard is active */\n  active: boolean;\n  /** Prevent iOS/macOS edge back gesture. @default true */\n  preventEdgeBack?: boolean;\n  /** Prevent overscroll bounce effect. @default true */\n  preventOverscroll?: boolean;\n  /** Width of edge zone where back gesture is prevented. @default 20 */\n  edgeWidth?: number;\n};\n\n/**\n * Result from useNativeGestureGuard hook.\n */\nexport type UseNativeGestureGuardResult = {\n  /** Props to spread on the container element */\n  containerProps: React.HTMLAttributes<HTMLElement> & {\n    style: React.CSSProperties;\n  };\n};\n\n/**\n * Default swipe input thresholds.\n *\n * - distanceThreshold: 100px is ~27% of a 375px mobile screen\n * - velocityThreshold: 0.5px/ms = 500px/s, a moderate flick speed\n * - lockThreshold: 10px before direction is locked\n */\nexport const DEFAULT_SWIPE_THRESHOLDS: SwipeInputThresholds = {\n  distanceThreshold: 100,\n  velocityThreshold: 0.5,\n  lockThreshold: 10,\n};\n\n/**\n * Default edge width for edge gesture detection.\n */\nexport const DEFAULT_EDGE_WIDTH = 20;\n\n/**\n * Initial idle state for SwipeInputState.\n */\nexport const IDLE_SWIPE_INPUT_STATE: SwipeInputState = {\n  phase: \"idle\",\n  displacement: { x: 0, y: 0 },\n  velocity: { x: 0, y: 0 },\n  direction: 0,\n};\n","/**\n * @file Hook for detecting swipe gestures on a container element.\n *\n * Combines pointer tracking and directional locking to detect swipe gestures.\n * Also supports trackpad two-finger swipe via wheel events.\n * Returns swipe state and container props for gesture handling.\n */\nimport * as React from \"react\";\nimport { usePointerTracking } from \"./usePointerTracking.js\";\nimport { useDirectionalLock } from \"./useDirectionalLock.js\";\nimport { useEffectEvent } from \"../useEffectEvent.js\";\nimport { calculateVelocity, determineDirection } from \"./utils.js\";\nimport type {\n  GestureAxis,\n  SwipeInputState,\n  SwipeInputThresholds,\n  UseSwipeInputOptions,\n  UseSwipeInputResult,\n  Vector2,\n} from \"./types.js\";\nimport { DEFAULT_SWIPE_THRESHOLDS, IDLE_SWIPE_INPUT_STATE } from \"./types.js\";\n\n/** Idle timeout to reset wheel state after swipe stops */\nconst WHEEL_RESET_TIMEOUT = 150;\n\n/**\n * Evaluate swipe end and call callback if threshold is met.\n */\nconst evaluateSwipeEnd = (\n  displacement: Vector2,\n  velocity: Vector2,\n  axis: GestureAxis,\n  thresholds: SwipeInputThresholds,\n  onSwipeEnd: ((state: SwipeInputState) => void) | undefined,\n): void => {\n  const axisDisplacement = axis === \"horizontal\" ? displacement.x : displacement.y;\n  const axisVelocity = axis === \"horizontal\" ? velocity.x : velocity.y;\n\n  const absDisplacement = Math.abs(axisDisplacement);\n  const absVelocity = Math.abs(axisVelocity);\n\n  const triggered = absDisplacement >= thresholds.distanceThreshold || absVelocity >= thresholds.velocityThreshold;\n\n  if (triggered) {\n    const direction = determineDirection(axisDisplacement);\n    const endState: SwipeInputState = {\n      phase: \"ended\",\n      displacement,\n      velocity,\n      direction,\n    };\n    onSwipeEnd?.(endState);\n  }\n};\n\n/**\n * Hook for detecting swipe gestures on a container element.\n */\nexport function useSwipeInput(options: UseSwipeInputOptions): UseSwipeInputResult {\n  const {\n    containerRef,\n    axis,\n    enabled = true,\n    thresholds: customThresholds,\n    onSwipeEnd,\n    enableWheel = true,\n    pointerStartFilter,\n  } = options;\n\n  const thresholds: SwipeInputThresholds = {\n    ...DEFAULT_SWIPE_THRESHOLDS,\n    ...customThresholds,\n  };\n\n  // Stable callback for swipe end\n  const handleSwipeEnd = useEffectEvent(onSwipeEnd);\n\n  // ===== Pointer-based swipe tracking =====\n  const { state: tracking, onPointerDown: baseOnPointerDown } = usePointerTracking({\n    enabled,\n  });\n\n  // Wrap pointer down handler with optional filter\n  const onPointerDown = React.useCallback(\n    (event: React.PointerEvent) => {\n      if (!enabled) {\n        return;\n      }\n      if (pointerStartFilter) {\n        const container = containerRef.current;\n        if (!container) {\n          return;\n        }\n        if (!pointerStartFilter(event, container)) {\n          return;\n        }\n      }\n      baseOnPointerDown(event);\n    },\n    [enabled, pointerStartFilter, containerRef, baseOnPointerDown],\n  );\n\n  const { lockedAxis, isLocked } = useDirectionalLock({\n    tracking,\n    lockThreshold: thresholds.lockThreshold,\n  });\n\n  const lastActiveStateRef = React.useRef<SwipeInputState | null>(null);\n\n  // Prevent native scroll when swiping on iOS\n  const isLockedToSwipeAxisRef = React.useRef(false);\n\n  React.useEffect(() => {\n    isLockedToSwipeAxisRef.current = isLocked ? lockedAxis === axis : false;\n  }, [isLocked, lockedAxis, axis]);\n\n  React.useEffect(() => {\n    const container = containerRef.current;\n    if (!container || !enabled) {\n      return;\n    }\n    const disableTouchMove = (event: TouchEvent) => {\n      event.preventDefault();\n    };\n    const handleTouchStart = (event: TouchEvent) => {\n      if (isLockedToSwipeAxisRef.current) {\n        event.preventDefault();\n      }\n      document.addEventListener(\"touchmove\", disableTouchMove, { passive: false });\n    };\n    const handleTouchEnd = () => {\n      document.removeEventListener(\"touchmove\", disableTouchMove);\n    };\n    document.addEventListener(\"touchend\", handleTouchEnd);\n    document.addEventListener(\"touchcancel\", handleTouchEnd);\n    container.addEventListener(\"touchstart\", handleTouchStart, { passive: false });\n\n    return () => {\n      container.removeEventListener(\"touchstart\", handleTouchStart);\n      document.removeEventListener(\"touchend\", handleTouchEnd);\n      document.removeEventListener(\"touchcancel\", handleTouchEnd);\n    };\n  }, [containerRef, enabled]);\n\n  // ===== Wheel-based swipe tracking =====\n  const [wheelState, setWheelState] = React.useState<SwipeInputState>(IDLE_SWIPE_INPUT_STATE);\n  const wheelAccumulatedRef = React.useRef({ x: 0, y: 0 });\n  const wheelIdleTimerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);\n  const wheelLockedRef = React.useRef(false);\n  const wheelLockedAxisRef = React.useRef<GestureAxis | null>(null);\n\n  const resetWheelState = React.useCallback(() => {\n    wheelAccumulatedRef.current = { x: 0, y: 0 };\n    wheelLockedRef.current = false;\n    wheelLockedAxisRef.current = null;\n    setWheelState(IDLE_SWIPE_INPUT_STATE);\n  }, []);\n\n  const endWheelSwipe = React.useCallback(() => {\n    const displacement = { ...wheelAccumulatedRef.current };\n    evaluateSwipeEnd(displacement, { x: 0, y: 0 }, axis, thresholds, handleSwipeEnd);\n    resetWheelState();\n  }, [axis, thresholds, handleSwipeEnd, resetWheelState]);\n\n  const handleWheel = useEffectEvent((event: WheelEvent) => {\n    if (!enabled || !enableWheel || tracking.isDown) {\n      return;\n    }\n\n    const { deltaX, deltaY } = event;\n\n    // Direction lock\n    if (!wheelLockedRef.current) {\n      const absX = Math.abs(deltaX);\n      const absY = Math.abs(deltaY);\n\n      if (absX >= thresholds.lockThreshold || absY >= thresholds.lockThreshold) {\n        wheelLockedRef.current = true;\n        wheelLockedAxisRef.current = absX > absY ? \"horizontal\" : \"vertical\";\n      }\n    }\n\n    // If locked to wrong axis, ignore\n    if (wheelLockedRef.current && wheelLockedAxisRef.current !== axis) {\n      return;\n    }\n\n    // Accumulate displacement (negate: wheel delta is scroll direction)\n    wheelAccumulatedRef.current.x -= deltaX;\n    wheelAccumulatedRef.current.y -= deltaY;\n\n    const accumulated = wheelAccumulatedRef.current;\n    const axisDisplacement = axis === \"horizontal\" ? accumulated.x : accumulated.y;\n\n    setWheelState({\n      phase: \"swiping\",\n      displacement: { ...accumulated },\n      velocity: { x: 0, y: 0 },\n      direction: determineDirection(axisDisplacement),\n    });\n\n    // When wheel stops, treat as \"release\"\n    if (wheelIdleTimerRef.current !== null) {\n      clearTimeout(wheelIdleTimerRef.current);\n    }\n    wheelIdleTimerRef.current = setTimeout(endWheelSwipe, WHEEL_RESET_TIMEOUT);\n  });\n\n  // Set up wheel event listener\n  React.useEffect(() => {\n    const container = containerRef.current;\n    if (!container || !enabled || !enableWheel) {\n      return;\n    }\n\n    const listener = (event: WheelEvent) => {\n      event.preventDefault();\n      handleWheel(event);\n    };\n\n    container.addEventListener(\"wheel\", listener, { passive: false });\n\n    return () => {\n      container.removeEventListener(\"wheel\", listener);\n      if (wheelIdleTimerRef.current !== null) {\n        clearTimeout(wheelIdleTimerRef.current);\n      }\n    };\n  }, [containerRef, enabled, enableWheel, handleWheel]);\n\n  React.useEffect(() => {\n    return () => {\n      if (wheelIdleTimerRef.current !== null) {\n        clearTimeout(wheelIdleTimerRef.current);\n      }\n    };\n  }, []);\n\n  // ===== Pointer swipe state =====\n  const pointerState = React.useMemo<SwipeInputState>(() => {\n    if (!tracking.isDown || !tracking.start || !tracking.current) {\n      return IDLE_SWIPE_INPUT_STATE;\n    }\n\n    const deltaX = tracking.current.x - tracking.start.x;\n    const deltaY = tracking.current.y - tracking.start.y;\n    const displacement = { x: deltaX, y: deltaY };\n\n    const velocity = {\n      x: calculateVelocity(deltaX, tracking.start.timestamp, tracking.current.timestamp),\n      y: calculateVelocity(deltaY, tracking.start.timestamp, tracking.current.timestamp),\n    };\n\n    if (!isLocked || lockedAxis !== axis) {\n      return { phase: \"tracking\", displacement, velocity, direction: 0 };\n    }\n\n    const axisDisplacement = axis === \"horizontal\" ? deltaX : deltaY;\n    return {\n      phase: \"swiping\",\n      displacement,\n      velocity,\n      direction: determineDirection(axisDisplacement),\n    };\n  }, [tracking.isDown, tracking.start, tracking.current, isLocked, lockedAxis, axis]);\n\n  React.useEffect(() => {\n    if (pointerState.phase !== \"idle\") {\n      lastActiveStateRef.current = pointerState;\n    }\n  }, [pointerState]);\n\n  // Handle pointer up (but not cancel)\n  React.useEffect(() => {\n    if (tracking.isDown) {\n      return;\n    }\n\n    const lastState = lastActiveStateRef.current;\n    if (!lastState || (lastState.phase !== \"swiping\" && lastState.phase !== \"tracking\")) {\n      return;\n    }\n\n    lastActiveStateRef.current = null;\n\n    // Skip navigation if the gesture was canceled (e.g., browser took over for native scroll)\n    if (tracking.wasCanceled) {\n      return;\n    }\n\n    evaluateSwipeEnd(lastState.displacement, lastState.velocity, axis, thresholds, handleSwipeEnd);\n  }, [tracking.isDown, tracking.wasCanceled, axis, thresholds, handleSwipeEnd]);\n\n  // Merge states\n  const state = pointerState.phase !== \"idle\" ? pointerState : wheelState;\n\n  const containerProps = React.useMemo(() => {\n    const touchAction = axis === \"horizontal\" ? \"pan-y pinch-zoom\" : \"pan-x pinch-zoom\";\n    return {\n      onPointerDown,\n      style: {\n        touchAction,\n        userSelect: \"none\" as const,\n        WebkitUserSelect: \"none\" as const,\n      },\n    };\n  }, [axis, onPointerDown]);\n\n  return { state, containerProps };\n}\n","/**\n * @file Hook for detecting swipe gestures that originate from the edge of a container.\n *\n * Edge swipes are commonly used for \"swipe back\" navigation in mobile apps.\n * This hook detects swipes that start within a configurable edge zone.\n *\n * Built on top of useSwipeInput with edge zone filtering.\n */\nimport * as React from \"react\";\nimport { useSwipeInput } from \"./useSwipeInput.js\";\nimport type {\n  GestureAxis,\n  GestureEdge,\n  SwipeInputState,\n  UseEdgeSwipeInputOptions,\n  UseEdgeSwipeInputResult,\n} from \"./types.js\";\nimport { DEFAULT_EDGE_WIDTH, DEFAULT_SWIPE_THRESHOLDS, IDLE_SWIPE_INPUT_STATE } from \"./types.js\";\n\n/**\n * Get the axis associated with an edge.\n */\nconst getAxisForEdge = (edge: GestureEdge): GestureAxis => {\n  if (edge === \"left\" || edge === \"right\") {\n    return \"horizontal\";\n  }\n  return \"vertical\";\n};\n\n/**\n * Check if a point is within the edge zone of a container.\n */\nconst isInEdgeZone = (\n  clientX: number,\n  clientY: number,\n  container: HTMLElement,\n  edge: GestureEdge,\n  edgeWidth: number,\n): boolean => {\n  const rect = container.getBoundingClientRect();\n\n  switch (edge) {\n    case \"left\":\n      return clientX >= rect.left && clientX <= rect.left + edgeWidth;\n    case \"right\":\n      return clientX >= rect.right - edgeWidth && clientX <= rect.right;\n    case \"top\":\n      return clientY >= rect.top && clientY <= rect.top + edgeWidth;\n    case \"bottom\":\n      return clientY >= rect.bottom - edgeWidth && clientY <= rect.bottom;\n  }\n};\n\n/**\n * Hook for detecting swipe gestures that originate from the edge of a container.\n *\n * This is useful for implementing \"swipe back\" navigation patterns where\n * the user must start their swipe from the edge of the screen.\n *\n * @example\n * ```tsx\n * const containerRef = useRef<HTMLDivElement>(null);\n * const { isEdgeGesture, state, containerProps } = useEdgeSwipeInput({\n *   containerRef,\n *   edge: \"left\",\n *   edgeWidth: 20,\n *   onSwipeEnd: (state) => {\n *     if (state.direction === 1) goBack();\n *   },\n * });\n *\n * return <div ref={containerRef} {...containerProps}>{children}</div>;\n * ```\n */\nexport function useEdgeSwipeInput(options: UseEdgeSwipeInputOptions): UseEdgeSwipeInputResult {\n  const {\n    containerRef,\n    edge,\n    edgeWidth = DEFAULT_EDGE_WIDTH,\n    enabled = true,\n    thresholds: customThresholds,\n    onSwipeEnd,\n  } = options;\n\n  const thresholds = {\n    ...DEFAULT_SWIPE_THRESHOLDS,\n    ...customThresholds,\n  };\n\n  const axis = getAxisForEdge(edge);\n\n  // Track whether the current gesture started from the edge\n  const [isEdgeGesture, setIsEdgeGesture] = React.useState(false);\n\n  // Create edge zone filter for pointer events\n  const pointerStartFilter = React.useCallback(\n    (event: React.PointerEvent, container: HTMLElement): boolean => {\n      const inEdge = isInEdgeZone(event.clientX, event.clientY, container, edge, edgeWidth);\n      setIsEdgeGesture(inEdge);\n      return inEdge;\n    },\n    [edge, edgeWidth],\n  );\n\n  // Use base swipe input with edge filtering\n  const { state, containerProps } = useSwipeInput({\n    containerRef,\n    axis,\n    enabled,\n    thresholds,\n    onSwipeEnd,\n    enableWheel: false, // Edge swipe doesn't use wheel events\n    pointerStartFilter,\n  });\n\n  // Reset edge gesture state when swipe ends\n  React.useEffect(() => {\n    if (state.phase === \"idle\") {\n      setIsEdgeGesture(false);\n    }\n  }, [state.phase]);\n\n  // If not an edge gesture, return idle state\n  const effectiveState: SwipeInputState = isEdgeGesture ? state : IDLE_SWIPE_INPUT_STATE;\n\n  return {\n    isEdgeGesture,\n    state: effectiveState,\n    containerProps,\n  };\n}\n","/**\n * @file Hook for preventing conflicts with native OS gestures.\n *\n * This hook helps prevent conflicts with:\n * - iOS/macOS edge swipe back navigation\n * - Overscroll bounce effects\n *\n * It applies appropriate CSS properties and event handlers to the container.\n */\nimport * as React from \"react\";\nimport type {\n  UseNativeGestureGuardOptions,\n  UseNativeGestureGuardResult,\n} from \"./types.js\";\nimport { DEFAULT_EDGE_WIDTH } from \"./types.js\";\n\n/**\n * Check if a pointer event is within the left edge zone.\n */\nconst isInLeftEdge = (clientX: number, container: HTMLElement, edgeWidth: number): boolean => {\n  const rect = container.getBoundingClientRect();\n  return clientX >= rect.left && clientX <= rect.left + edgeWidth;\n};\n\n/**\n * Hook for preventing conflicts with native OS gestures.\n *\n * When active, this hook:\n * - Prevents iOS/macOS edge back gesture by capturing pointerdown events in the edge zone\n * - Prevents overscroll bounce effect using CSS overscroll-behavior\n * - Dynamically applies overscroll-behavior: none to html element during gesture\n *\n * @example\n * ```tsx\n * const containerRef = useRef<HTMLDivElement>(null);\n * const { containerProps } = useNativeGestureGuard({\n *   containerRef,\n *   active: isSwipeActive,\n *   preventEdgeBack: true,\n *   preventOverscroll: true,\n * });\n *\n * return <div ref={containerRef} {...containerProps}>{children}</div>;\n * ```\n */\nexport function useNativeGestureGuard(options: UseNativeGestureGuardOptions): UseNativeGestureGuardResult {\n  const {\n    containerRef,\n    active,\n    preventEdgeBack = true,\n    preventOverscroll = true,\n    edgeWidth = DEFAULT_EDGE_WIDTH,\n  } = options;\n\n  // Track previous html overscroll-behavior value for restoration\n  const previousHtmlOverscrollRef = React.useRef<string | null>(null);\n\n  // Apply overscroll-behavior to html synchronously (called from onPointerDown)\n  const applyHtmlOverscroll = React.useCallback(() => {\n    if (!preventOverscroll) {\n      return;\n    }\n\n    const html = document.documentElement;\n    if (previousHtmlOverscrollRef.current === null) {\n      previousHtmlOverscrollRef.current = html.style.overscrollBehavior;\n    }\n    html.style.overscrollBehavior = \"none\";\n  }, [preventOverscroll]);\n\n  // Remove overscroll-behavior from html when gesture ends\n  React.useEffect(() => {\n    if (active || !preventOverscroll) {\n      return;\n    }\n\n    // Cleanup: restore previous value when deactivated\n    if (previousHtmlOverscrollRef.current !== null) {\n      document.documentElement.style.overscrollBehavior = previousHtmlOverscrollRef.current;\n      previousHtmlOverscrollRef.current = null;\n    }\n  }, [active, preventOverscroll]);\n\n  // Cleanup on unmount\n  React.useEffect(() => {\n    return () => {\n      if (previousHtmlOverscrollRef.current !== null) {\n        document.documentElement.style.overscrollBehavior = previousHtmlOverscrollRef.current;\n        previousHtmlOverscrollRef.current = null;\n      }\n    };\n  }, []);\n\n  // Pointer down handler that prevents edge back gesture\n  // Note: This must run on EVERY pointerdown in edge zone, not just when active,\n  // because browser gesture recognition starts immediately on first touch.\n  const onPointerDown = React.useCallback((event: React.PointerEvent) => {\n    if (!preventEdgeBack) {\n      return;\n    }\n\n    const container = containerRef.current;\n    if (!container) {\n      return;\n    }\n\n    // Prevent for touch events in the left edge zone\n    // This must happen immediately, before we know if it's \"our\" gesture\n    if (event.pointerType === \"touch\" && isInLeftEdge(event.clientX, container, edgeWidth)) {\n      // Apply html overscroll-behavior synchronously before browser can recognize gesture\n      applyHtmlOverscroll();\n      // Prevent the browser from handling this as a back gesture\n      event.preventDefault();\n    }\n  }, [preventEdgeBack, containerRef, edgeWidth, applyHtmlOverscroll]);\n\n  // Build container props\n  // Styles are applied immediately (not waiting for active) to prevent browser gestures\n  const containerProps = React.useMemo(() => {\n    const style: React.CSSProperties = {\n      // Always apply to prevent browser navigation gestures\n      overscrollBehavior: preventOverscroll ? \"contain\" : undefined,\n      WebkitOverflowScrolling: \"touch\",\n    };\n\n    return {\n      onPointerDown: preventEdgeBack ? onPointerDown : undefined,\n      style,\n    };\n  }, [preventOverscroll, preventEdgeBack, onPointerDown]);\n\n  return {\n    containerProps,\n  };\n}\n"],"names":["INITIAL_STATE","createTimestampedPoint","clientX","clientY","usePointerTracking","options","enabled","primaryOnly","state","setState","React","reset","handlePointerDown","useEffectEvent","event","point","handlePointerMove","prev","handlePointerUp","handlePointerCancel","shouldTrackDocument","useDocumentPointerEvents","DEFAULT_LOCK_THRESHOLD","determineAxis","deltaX","deltaY","absX","absY","useDirectionalLock","tracking","lockThreshold","lockedAxis","setLockedAxis","axis","calculateVelocity","displacement","startTime","currentTime","elapsed","determineDirection","mergeGestureContainerProps","propsArray","mergedStyle","pointerDownHandlers","props","handler","isScrollableInDirection","element","container","direction","current","style","isHorizontal","overflow","scrollSize","scrollPos","IDLE_CONTINUOUS_OPERATION_STATE","DEFAULT_SWIPE_THRESHOLDS","DEFAULT_EDGE_WIDTH","IDLE_SWIPE_INPUT_STATE","WHEEL_RESET_TIMEOUT","evaluateSwipeEnd","velocity","thresholds","onSwipeEnd","axisDisplacement","axisVelocity","absDisplacement","absVelocity","useSwipeInput","containerRef","customThresholds","enableWheel","pointerStartFilter","handleSwipeEnd","baseOnPointerDown","onPointerDown","isLocked","lastActiveStateRef","isLockedToSwipeAxisRef","disableTouchMove","handleTouchStart","handleTouchEnd","wheelState","setWheelState","wheelAccumulatedRef","wheelIdleTimerRef","wheelLockedRef","wheelLockedAxisRef","resetWheelState","endWheelSwipe","handleWheel","accumulated","listener","pointerState","lastState","containerProps","getAxisForEdge","edge","isInEdgeZone","edgeWidth","rect","useEdgeSwipeInput","isEdgeGesture","setIsEdgeGesture","inEdge","isInLeftEdge","useNativeGestureGuard","active","preventEdgeBack","preventOverscroll","previousHtmlOverscrollRef","applyHtmlOverscroll","html"],"mappings":"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"}

package/dist/useNativeGestureGuard-CGYo6O0r.js

@@ -0,0 +1,347 @@
+import * as c from "react";
+import { u as S, b as V } from "./useDocumentPointerEvents-DXxw3qWj.js";
+const I = {
+  isDown: !1,
+  start: null,
+  current: null,
+  pointerId: null,
+  wasCanceled: !1
+}, H = (s, e) => ({
+  x: s,
+  y: e,
+  timestamp: performance.now()
+});
+function j(s) {
+  const { enabled: e, primaryOnly: r = !0 } = s, [t, n] = c.useState(I), l = c.useCallback(() => {
+    n(I);
+  }, []), i = S((u) => {
+    if (!e || r && !u.isPrimary || u.pointerType === "mouse" && u.button !== 0)
+      return;
+    const m = H(u.clientX, u.clientY);
+    n({
+      isDown: !0,
+      start: m,
+      current: m,
+      pointerId: u.pointerId,
+      wasCanceled: !1
+    });
+  }), f = S((u) => {
+    if (t.pointerId !== u.pointerId)
+      return;
+    const m = H(u.clientX, u.clientY);
+    n((v) => ({
+      ...v,
+      current: m
+    }));
+  }), d = S(() => {
+    n(I);
+  }), h = S(() => {
+    n({ ...I, wasCanceled: !0 });
+  }), o = t.isDown ? e : !1;
+  return V(o, {
+    onMove: f,
+    onUp: d,
+    onCancel: h
+  }), c.useEffect(() => {
+    !e && t.isDown && l();
+  }, [e, t.isDown, l]), {
+    state: t,
+    onPointerDown: i,
+    reset: l
+  };
+}
+const K = 10, Z = (s, e) => {
+  const r = Math.abs(s), t = Math.abs(e);
+  return r === 0 && t === 0 ? null : r > t * 1.5 ? "horizontal" : t > r * 1.5 ? "vertical" : null;
+};
+function q(s) {
+  const { tracking: e, lockThreshold: r = K } = s, [t, n] = c.useState(null), l = c.useCallback(() => {
+    n(null);
+  }, []);
+  return c.useEffect(() => {
+    if (!e.isDown) {
+      t !== null && l();
+      return;
+    }
+    if (t !== null || !e.start || !e.current)
+      return;
+    const i = e.current.x - e.start.x, f = e.current.y - e.start.y;
+    if (Math.max(Math.abs(i), Math.abs(f)) < r)
+      return;
+    const h = Z(i, f);
+    h !== null && n(h);
+  }, [e.isDown, e.start, e.current, t, r, l]), {
+    lockedAxis: t,
+    isLocked: t !== null,
+    reset: l
+  };
+}
+const U = (s, e, r) => {
+  const t = r - e;
+  return t <= 0 ? 0 : s / t;
+}, A = (s) => s > 0 ? 1 : s < 0 ? -1 : 0, re = (...s) => {
+  const e = {}, r = [];
+  for (const n of s)
+    Object.assign(e, n.style), n.onPointerDown && r.push(n.onPointerDown);
+  return {
+    onPointerDown: (n) => {
+      for (const l of r)
+        l?.(n);
+    },
+    style: e
+  };
+};
+function oe(s, e, r, t) {
+  let n = s;
+  for (; n !== null && n !== e; ) {
+    const l = getComputedStyle(n), i = r === "x", f = i ? l.overflowX : l.overflowY;
+    if (f === "scroll" || f === "auto") {
+      const h = i ? n.scrollWidth - n.clientWidth : n.scrollHeight - n.clientHeight;
+      if (h > 0) {
+        const o = i ? n.scrollLeft : n.scrollTop;
+        if (t === -1 && o > 1 || t === 1 && o < h - 1)
+          return !0;
+      }
+    }
+    n = n.parentElement;
+  }
+  return !1;
+}
+const se = {
+  phase: "idle",
+  displacement: { x: 0, y: 0 },
+  velocity: { x: 0, y: 0 }
+}, F = {
+  distanceThreshold: 100,
+  velocityThreshold: 0.5,
+  lockThreshold: 10
+}, G = 20, R = {
+  phase: "idle",
+  displacement: { x: 0, y: 0 },
+  velocity: { x: 0, y: 0 },
+  direction: 0
+}, J = 150, B = (s, e, r, t, n) => {
+  const l = r === "horizontal" ? s.x : s.y, i = r === "horizontal" ? e.x : e.y, f = Math.abs(l), d = Math.abs(i);
+  if (f >= t.distanceThreshold || d >= t.velocityThreshold) {
+    const o = A(l);
+    n?.({
+      phase: "ended",
+      displacement: s,
+      velocity: e,
+      direction: o
+    });
+  }
+};
+function Q(s) {
+  const {
+    containerRef: e,
+    axis: r,
+    enabled: t = !0,
+    thresholds: n,
+    onSwipeEnd: l,
+    enableWheel: i = !0,
+    pointerStartFilter: f
+  } = s, d = {
+    ...F,
+    ...n
+  }, h = S(l), { state: o, onPointerDown: u } = j({
+    enabled: t
+  }), m = c.useCallback(
+    (a) => {
+      if (t) {
+        if (f) {
+          const p = e.current;
+          if (!p || !f(a, p))
+            return;
+        }
+        u(a);
+      }
+    },
+    [t, f, e, u]
+  ), { lockedAxis: v, isLocked: b } = q({
+    tracking: o,
+    lockThreshold: d.lockThreshold
+  }), y = c.useRef(null), k = c.useRef(!1);
+  c.useEffect(() => {
+    k.current = b ? v === r : !1;
+  }, [b, v, r]), c.useEffect(() => {
+    const a = e.current;
+    if (!a || !t)
+      return;
+    const p = (T) => {
+      T.preventDefault();
+    }, E = (T) => {
+      k.current && T.preventDefault(), document.addEventListener("touchmove", p, { passive: !1 });
+    }, w = () => {
+      document.removeEventListener("touchmove", p);
+    };
+    return document.addEventListener("touchend", w), document.addEventListener("touchcancel", w), a.addEventListener("touchstart", E, { passive: !1 }), () => {
+      a.removeEventListener("touchstart", E), document.removeEventListener("touchend", w), document.removeEventListener("touchcancel", w);
+    };
+  }, [e, t]);
+  const [L, M] = c.useState(R), x = c.useRef({ x: 0, y: 0 }), D = c.useRef(null), P = c.useRef(!1), C = c.useRef(null), O = c.useCallback(() => {
+    x.current = { x: 0, y: 0 }, P.current = !1, C.current = null, M(R);
+  }, []), N = c.useCallback(() => {
+    const a = { ...x.current };
+    B(a, { x: 0, y: 0 }, r, d, h), O();
+  }, [r, d, h, O]), _ = S((a) => {
+    if (!t || !i || o.isDown)
+      return;
+    const { deltaX: p, deltaY: E } = a;
+    if (!P.current) {
+      const W = Math.abs(p), z = Math.abs(E);
+      (W >= d.lockThreshold || z >= d.lockThreshold) && (P.current = !0, C.current = W > z ? "horizontal" : "vertical");
+    }
+    if (P.current && C.current !== r)
+      return;
+    x.current.x -= p, x.current.y -= E;
+    const w = x.current, T = r === "horizontal" ? w.x : w.y;
+    M({
+      phase: "swiping",
+      displacement: { ...w },
+      velocity: { x: 0, y: 0 },
+      direction: A(T)
+    }), D.current !== null && clearTimeout(D.current), D.current = setTimeout(N, J);
+  });
+  c.useEffect(() => {
+    const a = e.current;
+    if (!a || !t || !i)
+      return;
+    const p = (E) => {
+      E.preventDefault(), _(E);
+    };
+    return a.addEventListener("wheel", p, { passive: !1 }), () => {
+      a.removeEventListener("wheel", p), D.current !== null && clearTimeout(D.current);
+    };
+  }, [e, t, i, _]), c.useEffect(() => () => {
+    D.current !== null && clearTimeout(D.current);
+  }, []);
+  const g = c.useMemo(() => {
+    if (!o.isDown || !o.start || !o.current)
+      return R;
+    const a = o.current.x - o.start.x, p = o.current.y - o.start.y, E = { x: a, y: p }, w = {
+      x: U(a, o.start.timestamp, o.current.timestamp),
+      y: U(p, o.start.timestamp, o.current.timestamp)
+    };
+    return !b || v !== r ? { phase: "tracking", displacement: E, velocity: w, direction: 0 } : {
+      phase: "swiping",
+      displacement: E,
+      velocity: w,
+      direction: A(r === "horizontal" ? a : p)
+    };
+  }, [o.isDown, o.start, o.current, b, v, r]);
+  c.useEffect(() => {
+    g.phase !== "idle" && (y.current = g);
+  }, [g]), c.useEffect(() => {
+    if (o.isDown)
+      return;
+    const a = y.current;
+    !a || a.phase !== "swiping" && a.phase !== "tracking" || (y.current = null, !o.wasCanceled && B(a.displacement, a.velocity, r, d, h));
+  }, [o.isDown, o.wasCanceled, r, d, h]);
+  const X = g.phase !== "idle" ? g : L, Y = c.useMemo(() => ({
+    onPointerDown: m,
+    style: {
+      touchAction: r === "horizontal" ? "pan-y pinch-zoom" : "pan-x pinch-zoom",
+      userSelect: "none",
+      WebkitUserSelect: "none"
+    }
+  }), [r, m]);
+  return { state: X, containerProps: Y };
+}
+const $ = (s) => s === "left" || s === "right" ? "horizontal" : "vertical", ee = (s, e, r, t, n) => {
+  const l = r.getBoundingClientRect();
+  switch (t) {
+    case "left":
+      return s >= l.left && s <= l.left + n;
+    case "right":
+      return s >= l.right - n && s <= l.right;
+    case "top":
+      return e >= l.top && e <= l.top + n;
+    case "bottom":
+      return e >= l.bottom - n && e <= l.bottom;
+  }
+};
+function ce(s) {
+  const {
+    containerRef: e,
+    edge: r,
+    edgeWidth: t = G,
+    enabled: n = !0,
+    thresholds: l,
+    onSwipeEnd: i
+  } = s, f = {
+    ...F,
+    ...l
+  }, d = $(r), [h, o] = c.useState(!1), u = c.useCallback(
+    (y, k) => {
+      const L = ee(y.clientX, y.clientY, k, r, t);
+      return o(L), L;
+    },
+    [r, t]
+  ), { state: m, containerProps: v } = Q({
+    containerRef: e,
+    axis: d,
+    enabled: n,
+    thresholds: f,
+    onSwipeEnd: i,
+    enableWheel: !1,
+    // Edge swipe doesn't use wheel events
+    pointerStartFilter: u
+  });
+  return c.useEffect(() => {
+    m.phase === "idle" && o(!1);
+  }, [m.phase]), {
+    isEdgeGesture: h,
+    state: h ? m : R,
+    containerProps: v
+  };
+}
+const te = (s, e, r) => {
+  const t = e.getBoundingClientRect();
+  return s >= t.left && s <= t.left + r;
+};
+function le(s) {
+  const {
+    containerRef: e,
+    active: r,
+    preventEdgeBack: t = !0,
+    preventOverscroll: n = !0,
+    edgeWidth: l = G
+  } = s, i = c.useRef(null), f = c.useCallback(() => {
+    if (!n)
+      return;
+    const o = document.documentElement;
+    i.current === null && (i.current = o.style.overscrollBehavior), o.style.overscrollBehavior = "none";
+  }, [n]);
+  c.useEffect(() => {
+    r || !n || i.current !== null && (document.documentElement.style.overscrollBehavior = i.current, i.current = null);
+  }, [r, n]), c.useEffect(() => () => {
+    i.current !== null && (document.documentElement.style.overscrollBehavior = i.current, i.current = null);
+  }, []);
+  const d = c.useCallback((o) => {
+    if (!t)
+      return;
+    const u = e.current;
+    u && o.pointerType === "touch" && te(o.clientX, u, l) && (f(), o.preventDefault());
+  }, [t, e, l, f]);
+  return {
+    containerProps: c.useMemo(() => ({
+      onPointerDown: t ? d : void 0,
+      style: {
+        // Always apply to prevent browser navigation gestures
+        overscrollBehavior: n ? "contain" : void 0,
+        WebkitOverflowScrolling: "touch"
+      }
+    }), [n, t, d])
+  };
+}
+export {
+  R as I,
+  le as a,
+  j as b,
+  se as c,
+  oe as i,
+  re as m,
+  ce as u
+};
+//# sourceMappingURL=useNativeGestureGuard-CGYo6O0r.js.map