https://stridenavigation.com/chunk-T4GYAOTA.js

1import {
2  GESTURE_CONTROLLER
3} from "./chunk-2VHYZHLL.js";
4
5// node_modules/@ionic/core/dist/esm/index-39782642.js
6var addEventListener = (el, eventName, callback, opts) => {
7  const listenerOpts = supportsPassive(el) ? {
8    capture: !!opts.capture,
9    passive: !!opts.passive
10  } : !!opts.capture;
11  let add;
12  let remove;
13  if (el["__zone_symbol__addEventListener"]) {
14    add = "__zone_symbol__addEventListener";
15    remove = "__zone_symbol__removeEventListener";
16  } else {
17    add = "addEventListener";
18    remove = "removeEventListener";
19  }
20  el[add](eventName, callback, listenerOpts);
21  return () => {
22    el[remove](eventName, callback, listenerOpts);
23  };
24};
25var supportsPassive = (node) => {
26  if (_sPassive === void 0) {
27    try {
28      const opts = Object.defineProperty({}, "passive", {
29        get: () => {
30          _sPassive = true;
31        }
32      });
33      node.addEventListener("optsTest", () => {
34        return;
35      }, opts);
36    } catch (e) {
37      _sPassive = false;
38    }
39  }
40  return !!_sPassive;
41};
42var _sPassive;
43var MOUSE_WAIT = 2e3;
44var createPointerEvents = (el, pointerDown, pointerMove, pointerUp, options) => {
45  let rmTouchStart;
46  let rmTouchMove;
47  let rmTouchEnd;
48  let rmTouchCancel;
49  let rmMouseStart;
50  let rmMouseMove;
51  let rmMouseUp;
52  let lastTouchEvent = 0;
53  const handleTouchStart = (ev) => {
54    lastTouchEvent = Date.now() + MOUSE_WAIT;
55    if (!pointerDown(ev)) {
56      return;
57    }
58    if (!rmTouchMove && pointerMove) {
59      rmTouchMove = addEventListener(el, "touchmove", pointerMove, options);
60    }
61    if (!rmTouchEnd) {
62      rmTouchEnd = addEventListener(ev.target, "touchend", handleTouchEnd, options);
63    }
64    if (!rmTouchCancel) {
65      rmTouchCancel = addEventListener(ev.target, "touchcancel", handleTouchEnd, options);
66    }
67  };
68  const handleMouseDown = (ev) => {
69    if (lastTouchEvent > Date.now()) {
70      return;
71    }
72    if (!pointerDown(ev)) {
73      return;
74    }
75    if (!rmMouseMove && pointerMove) {
76      rmMouseMove = addEventListener(getDocument(el), "mousemove", pointerMove, options);
77    }
78    if (!rmMouseUp) {
79      rmMouseUp = addEventListener(getDocument(el), "mouseup", handleMouseUp, options);
80    }
81  };
82  const handleTouchEnd = (ev) => {
83    stopTouch();
84    if (pointerUp) {
85      pointerUp(ev);
86    }
87  };
88  const handleMouseUp = (ev) => {
89    stopMouse();
90    if (pointerUp) {
91      pointerUp(ev);
92    }
93  };
94  const stopTouch = () => {
95    if (rmTouchMove) {
96      rmTouchMove();
97    }
98    if (rmTouchEnd) {
99      rmTouchEnd();
100    }
101    if (rmTouchCancel) {
102      rmTouchCancel();
103    }
104    rmTouchMove = rmTouchEnd = rmTouchCancel = void 0;
105  };
106  const stopMouse = () => {
107    if (rmMouseMove) {
108      rmMouseMove();
109    }
110    if (rmMouseUp) {
111      rmMouseUp();
112    }
113    rmMouseMove = rmMouseUp = void 0;
114  };
115  const stop = () => {
116    stopTouch();
117    stopMouse();
118  };
119  const enable = (isEnabled = true) => {
120    if (!isEnabled) {
121      if (rmTouchStart) {
122        rmTouchStart();
123      }
124      if (rmMouseStart) {
125        rmMouseStart();
126      }
127      rmTouchStart = rmMouseStart = void 0;
128      stop();
129    } else {
130      if (!rmTouchStart) {
131        rmTouchStart = addEventListener(el, "touchstart", handleTouchStart, options);
132      }
133      if (!rmMouseStart) {
134        rmMouseStart = addEventListener(el, "mousedown", handleMouseDown, options);
135      }
136    }
137  };
138  const destroy = () => {
139    enable(false);
140    pointerUp = pointerMove = pointerDown = void 0;
141  };
142  return {
143    enable,
144    stop,
145    destroy
146  };
147};
148var getDocument = (node) => {
149  return node instanceof Document ? node : node.ownerDocument;
150};
151var createPanRecognizer = (direction, thresh, maxAngle) => {
152  const radians = maxAngle * (Math.PI / 180);
153  const isDirX = direction === "x";

154  const maxCosine = Math.cos(radians);
155  const threshold = thresh * thresh;
156  let startX = 0;
157  let startY = 0;
158  let dirty = false;
159  let isPan = 0;
160  return {
161    start(x, y) {
162      startX = x;
163      startY = y;
164      isPan = 0;
165      dirty = true;
166    },
167    detect(x, y) {
168      if (!dirty) {
169        return false;
170      }
171      const deltaX = x - startX;
172      const deltaY = y - startY;
173      const distance = deltaX * deltaX + deltaY * deltaY;
174      if (distance < threshold) {
175        return false;
176      }
177      const hypotenuse = Math.sqrt(distance);
178      const cosine = (isDirX ? deltaX : deltaY) / hypotenuse;
179      if (cosine > maxCosine) {
180        isPan = 1;
181      } else if (cosine < -maxCosine) {
182        isPan = -1;
183      } else {
184        isPan = 0;
185      }
186      dirty = false;
187      return true;
188    },
189    isGesture() {
190      return isPan !== 0;
191    },
192    getDirection() {
193      return isPan;
194    }
195  };
196};
197var createGesture = (config) => {
198  let hasCapturedPan = false;
199  let hasStartedPan = false;
200  let hasFiredStart = true;
201  let isMoveQueued = false;
202  const finalConfig = Object.assign({
203    disableScroll: false,
204    direction: "x",
205    gesturePriority: 0,
206    passive: true,
207    maxAngle: 40,
208    threshold: 10
209  }, config);
210  const canStart = finalConfig.canStart;
211  const onWillStart = finalConfig.onWillStart;
212  const onStart = finalConfig.onStart;
213  const onEnd = finalConfig.onEnd;
214  const notCaptured = finalConfig.notCaptured;
215  const onMove = finalConfig.onMove;
216  const threshold = finalConfig.threshold;
217  const passive = finalConfig.passive;
218  const blurOnStart = finalConfig.blurOnStart;
219  const detail = {
220    type: "pan",
221    startX: 0,
222    startY: 0,
223    startTime: 0,
224    currentX: 0,
225    currentY: 0,
226    velocityX: 0,
227    velocityY: 0,
228    deltaX: 0,
229    deltaY: 0,
230    currentTime: 0,
231    event: void 0,
232    data: void 0
233  };
234  const pan = createPanRecognizer(finalConfig.direction, finalConfig.threshold, finalConfig.maxAngle);
235  const gesture = GESTURE_CONTROLLER.createGesture({
236    name: config.gestureName,
237    priority: config.gesturePriority,
238    disableScroll: config.disableScroll
239  });
240  const pointerDown = (ev) => {
241    const timeStamp = now(ev);
242    if (hasStartedPan || !hasFiredStart) {
243      return false;
244    }
245    updateDetail(ev, detail);
246    detail.startX = detail.currentX;
247    detail.startY = detail.currentY;
248    detail.startTime = detail.currentTime = timeStamp;
249    detail.velocityX = detail.velocityY = detail.deltaX = detail.deltaY = 0;
250    detail.event = ev;
251    if (canStart && canStart(detail) === false) {
252      return false;
253    }
254    gesture.release();
255    if (!gesture.start()) {
256      return false;
257    }
258    hasStartedPan = true;
259    if (threshold === 0) {
260      return tryToCapturePan();
261    }
262    pan.start(detail.startX, detail.startY);
263    return true;
264  };
265  const pointerMove = (ev) => {
266    if (hasCapturedPan) {
267      if (!isMoveQueued && hasFiredStart) {
268        isMoveQueued = true;
269        calcGestureData(detail, ev);
270        requestAnimationFrame(fireOnMove);
271      }
272      return;
273    }
274    calcGestureData(detail, ev);
275    if (pan.detect(detail.currentX, detail.currentY)) {
276      if (!pan.isGesture() || !tryToCapturePan()) {
277        abortGesture();
278      }
279    }
280  };
281  const fireOnMove = () => {
282    if (!hasCapturedPan) {
283      return;
284    }
285    isMoveQueued = false;
286    if (onMove) {
287      onMove(detail);
288    }
289  };
290  const tryToCapturePan = () => {
291    if (!gesture.capture()) {
292      return false;
293    }
294    hasCapturedPan = true;
295    hasFiredStart = false;

296    detail.startX = detail.currentX;
297    detail.startY = detail.currentY;
298    detail.startTime = detail.currentTime;
299    if (onWillStart) {
300      onWillStart(detail).then(fireOnStart);
301    } else {
302      fireOnStart();
303    }
304    return true;
305  };
306  const blurActiveElement = () => {
307    if (typeof document !== "undefined") {
308      const activeElement = document.activeElement;
309      if (activeElement === null || activeElement === void 0 ? void 0 : activeElement.blur) {
310        activeElement.blur();
311      }
312    }
313  };
314  const fireOnStart = () => {
315    if (blurOnStart) {
316      blurActiveElement();
317    }
318    if (onStart) {
319      onStart(detail);
320    }
321    hasFiredStart = true;
322  };
323  const reset = () => {
324    hasCapturedPan = false;
325    hasStartedPan = false;
326    isMoveQueued = false;
327    hasFiredStart = true;
328    gesture.release();
329  };
330  const pointerUp = (ev) => {
331    const tmpHasCaptured = hasCapturedPan;
332    const tmpHasFiredStart = hasFiredStart;
333    reset();
334    if (!tmpHasFiredStart) {
335      return;
336    }
337    calcGestureData(detail, ev);
338    if (tmpHasCaptured) {
339      if (onEnd) {
340        onEnd(detail);
341      }
342      return;
343    }
344    if (notCaptured) {
345      notCaptured(detail);
346    }
347  };
348  const pointerEvents = createPointerEvents(finalConfig.el, pointerDown, pointerMove, pointerUp, {
349    capture: false,
350    passive
351  });
352  const abortGesture = () => {
353    reset();
354    pointerEvents.stop();
355    if (notCaptured) {
356      notCaptured(detail);
357    }
358  };
359  return {
360    enable(enable = true) {
361      if (!enable) {
362        if (hasCapturedPan) {
363          pointerUp(void 0);
364        }
365        reset();
366      }
367      pointerEvents.enable(enable);
368    },
369    destroy() {
370      gesture.destroy();
371      pointerEvents.destroy();
372    }
373  };
374};
375var calcGestureData = (detail, ev) => {
376  if (!ev) {
377    return;
378  }
379  const prevX = detail.currentX;
380  const prevY = detail.currentY;
381  const prevT = detail.currentTime;
382  updateDetail(ev, detail);
383  const currentX = detail.currentX;
384  const currentY = detail.currentY;
385  const timestamp = detail.currentTime = now(ev);
386  const timeDelta = timestamp - prevT;
387  if (timeDelta > 0 && timeDelta < 100) {
388    const velocityX = (currentX - prevX) / timeDelta;
389    const velocityY = (currentY - prevY) / timeDelta;
390    detail.velocityX = velocityX * 0.7 + detail.velocityX * 0.3;
391    detail.velocityY = velocityY * 0.7 + detail.velocityY * 0.3;
392  }
393  detail.deltaX = currentX - detail.startX;
394  detail.deltaY = currentY - detail.startY;
395  detail.event = ev;
396};
397var updateDetail = (ev, detail) => {
398  let x = 0;
399  let y = 0;
400  if (ev) {
401    const changedTouches = ev.changedTouches;
402    if (changedTouches && changedTouches.length > 0) {
403      const touch = changedTouches[0];
404      x = touch.clientX;
405      y = touch.clientY;
406    } else if (ev.pageX !== void 0) {
407      x = ev.pageX;
408      y = ev.pageY;
409    }
410  }
411  detail.currentX = x;
412  detail.currentY = y;
413};
414var now = (ev) => {
415  return ev.timeStamp || Date.now();
416};
417
418export {
419  createGesture
420};